Skip to main content
GET
/
transcriptions
/
{appointmentId}
Get Transcriptions by Appointment
curl --request GET \
  --url https://api.example.com/transcriptions/{appointmentId} \
  --header 'Authorization: <authorization>'
import requests

url = "https://api.example.com/transcriptions/{appointmentId}"

headers = {"Authorization": "<authorization>"}

response = requests.get(url, headers=headers)

print(response.text)
const options = {method: 'GET', headers: {Authorization: '<authorization>'}};

fetch('https://api.example.com/transcriptions/{appointmentId}', options)
.then(res => res.json())
.then(res => console.log(res))
.catch(err => console.error(err));
<?php

$curl = curl_init();

curl_setopt_array($curl, [
CURLOPT_URL => "https://api.example.com/transcriptions/{appointmentId}",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "GET",
CURLOPT_HTTPHEADER => [
"Authorization: <authorization>"
],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
package main

import (
"fmt"
"net/http"
"io"
)

func main() {

url := "https://api.example.com/transcriptions/{appointmentId}"

req, _ := http.NewRequest("GET", url, nil)

req.Header.Add("Authorization", "<authorization>")

res, _ := http.DefaultClient.Do(req)

defer res.Body.Close()
body, _ := io.ReadAll(res.Body)

fmt.Println(string(body))

}
HttpResponse<String> response = Unirest.get("https://api.example.com/transcriptions/{appointmentId}")
.header("Authorization", "<authorization>")
.asString();
require 'uri'
require 'net/http'

url = URI("https://api.example.com/transcriptions/{appointmentId}")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = '<authorization>'

response = http.request(request)
puts response.read_body
{
  "success": true,
  "data": [
    {
      "_id": "<string>",
      "appointment_id": "<string>",
      "transcription": [
        {}
      ],
      "createdAt": "<string>",
      "updatedAt": "<string>"
    }
  ],
  "appointmentStatus": "<string>",
  "errorReason": "<string>",
  "appointmentUpdatedAt": "<string>"
}

Overview

Returns the transcription(s) stored for a specific appointment, looked up by appointment_id, together with the parent appointment’s current processing state (appointmentStatus, errorReason, and appointmentUpdatedAt). This lets a client render the transcribing / processing / error state in a single request. If the appointment exists, the caller must be its owning doctor. Because only one transcription may exist per appointment, the returned data array contains zero or one transcription in practice.
The path value is an appointment ObjectId. The endpoint returns the transcriptions whose appointment_id matches it.

Authentication

Authorization
string
required
Bearer JWT token. The calling user is derived from the token.
Authorization: Bearer <JWT>

Path Parameters

appointmentId
string
required
The appointment ObjectId. Transcriptions are looked up by appointment_id; if the appointment exists the caller must be its owning doctor.
665f8a1b2c3d4e5f6789012f3

Response

success
boolean
required
Indicates whether the request succeeded.
data
array
Array of transcription objects for the appointment (0 or 1 element in practice).
appointmentStatus
string
The parent appointment’s current status (e.g. transcribing, processing, error_transcription), or null if the appointment does not exist.
errorReason
string
The parent appointment’s error reason, or null when there is none.
appointmentUpdatedAt
string
The parent appointment’s last-update timestamp (ISO 8601), or null if the appointment does not exist. Useful for detecting a stalled status.
Additional fields (for example __v) may appear on the transcription object. Treat any field not documented here as opaque.

Example Request

curl -X GET \
  'https://app.medisync.me/api/transcriptions/665f8a1b2c3d4e5f6789012f3' \
  -H 'Authorization: Bearer <JWT>'
const response = await fetch(
  'https://app.medisync.me/api/transcriptions/665f8a1b2c3d4e5f6789012f3',
  {
    method: 'GET',
    headers: {
      'Authorization': 'Bearer <JWT>'
    }
  }
);

const result = await response.json();
import requests

headers = {'Authorization': 'Bearer <JWT>'}

response = requests.get(
    'https://app.medisync.me/api/transcriptions/665f8a1b2c3d4e5f6789012f3',
    headers=headers
)

result = response.json()

Example Response

Success (200) - Transcription Present
{
  "success": true,
  "data": [
    {
      "_id": "665f8a1b2c3d4e5f6789012f7",
      "appointment_id": "665f8a1b2c3d4e5f6789012f3",
      "transcription": [
        { "sender": "speaker_0", "message": "Guten Tag, was fuehrt Sie zu mir?", "start_time": "00:00:01,200" },
        { "sender": "speaker_1", "message": "Ich habe seit heute Morgen Brustschmerzen.", "start_time": "00:00:05,800" }
      ],
      "createdAt": "2026-06-30T10:30:00.000Z",
      "updatedAt": "2026-06-30T10:30:00.000Z"
    }
  ],
  "appointmentStatus": "processing",
  "errorReason": null,
  "appointmentUpdatedAt": "2026-06-30T10:31:00.000Z"
}
Success (200) - No Transcription On File
{
  "success": true,
  "data": [],
  "appointmentStatus": "transcribing",
  "errorReason": null,
  "appointmentUpdatedAt": "2026-06-30T10:30:00.000Z"
}

Error Responses

401 Unauthorized
{
  "success": false,
  "message": "Unauthorized"
}
403 Forbidden (not the owning doctor)
{
  "success": false,
  "error": "Forbidden"
}
The Unauthorized response uses the message field; handler-level errors use the error field. Unexpected server errors return 500 { "success": false, "error": "<message>" }. When the appointment does not exist the ownership check is skipped and the three appointment fields (appointmentStatus, errorReason, appointmentUpdatedAt) are returned as null.

Behavior Notes

  • Lookup by appointment: Transcriptions are located by appointment_id; the path value is an appointment id.
  • Combined state: The appointment’s status, error_reason, and updatedAt are returned alongside the transcription so a client can render processing state in one call.
  • Ownership: If the appointment exists, only its owning doctor may read the transcription; otherwise the request returns 403 Forbidden.
  • At most one transcription: Because creation rejects duplicates, data holds 0 or 1 element.