> ## Documentation Index
> Fetch the complete documentation index at: https://developer.suki.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Encounter Information

> Get encounter information to look up notes, sessions, and artifact availability for an EMR encounter

Use this endpoint to get an overview of all ambient sessions and artifacts associated with an <Tooltip tip="The partner EMR or EHR visit identifier (emr_encounter_id) that anchors interoperable ambient notes across modalities. Required for cross-modality ambient workflows. Accepts a UUID or non-UUID value, at most 36 characters. Distinct from the Ambient API encounter_id field." cta="View in Glossary" href="/Glossary/e#emr-encounter-id">`emr_encounter_id`</Tooltip>.

Pass the same `emr_encounter_id` you used when creating interoperable ambient sessions. The value can be a **UUID or non-UUID** string and must be at most **36 characters**.

The response provides read-only metadata for the visit, including:

* Note IDs
* Session IDs
* Timestamps
* Session statuses
* Available artifacts

This endpoint does **not** return note content, transcripts, or recordings. Use the existing session-level and note-level `GET` endpoints to retrieve those artifacts when they are listed in the response. For example, if `artifacts` includes `content`, `transcript`, or `recording`, use the corresponding `GET` endpoint to fetch the data.

<Tip>
  Use this endpoint when you need sessions, statuses, and available artifacts for a visit. Use [List encounter notes](/api-reference/ambient-content/list-encounter-notes) when you only need note IDs for that `emr_encounter_id`. Refer to [Work with shared notes](/documentation/how-to/ambient-clinical-notes/retrieve-note-and-encounter-content) for how to choose between these endpoints in your application UI.
</Tip>

<Note>
  Cross-modality ambient workflows require `emr_encounter_id` when you create a session. Without it, notes are not interoperable across modalities. Refer to [Ambient interoperability](/documentation/concepts/ambient-clinical-notes/ambient-interoperability) for more details.
</Note>

## Code examples

**Language tabs (agents):** Equivalent code samples are available in: Python, TypeScript. Humans see one language at a time. Use the variant that matches the user's stack; behavior is the same across tabs.

<Tabs>
  <Tab title="Python">
    ```python expandable theme={"theme":{"light":"github-dark","dark":"material-theme-darker"}}
    import json
    import requests

    BASE_URL = "https://sdp.suki.ai"

    # Same emr_encounter_id you passed on Create Ambient Session
    emr_encounter_id = "<emr_encounter_id>"

    # Get sdp_suki_token from Login: POST /api/v1/auth/login
    sdp_suki_token = "<sdp_suki_token>"

    # Required for single_auth partners
    sdp_provider_id = "<sdp_provider_id>"

    url = f"{BASE_URL}/api/v1/ambient/encounter/{emr_encounter_id}/info"

    headers = {
        "sdp_suki_token": sdp_suki_token,
        "sdp_provider_id": sdp_provider_id,
    }

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

    print("HTTP status:", response.status_code)

    try:
        response_body = response.json()
    except ValueError:
        print("Response was not JSON:")
        print(response.text)
        raise SystemExit(1)

    print("Response body:")
    print(json.dumps(response_body, indent=2))

    if response.status_code == 200:
        notes = response_body.get("notes") or []
        print(f"Notes found: {len(notes)}")

        for note in notes:
            note_id = note.get("note_id")
            print("note_id:", note_id)
            print("created_at:", note.get("created_at"))
            print("updated_at:", note.get("updated_at"))

            for session in note.get("sessions") or []:
                print("  session_id:", session.get("session_id"))
                print("  status:", session.get("status"))
                print("  artifacts:", session.get("artifacts"))

            print(
                "Use note_id with Get Note Content, Get Note Context, "
                "and Get Note Structured Data."
            )
    else:
        print("Get Encounter Info failed.")
        if isinstance(response_body, dict):
            print("code:", response_body.get("code"))
            print("message:", response_body.get("message"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript expandable theme={"theme":{"light":"github-dark","dark":"material-theme-darker"}}
    const BASE_URL = "https://sdp.suki.ai";

    // Same emr_encounter_id you passed on Create Ambient Session
    const emrEncounterId = "<emr_encounter_id>";

    // Get sdp_suki_token from Login: POST /api/v1/auth/login
    const sdpSukiToken = "<sdp_suki_token>";

    // Required for single_auth partners
    const sdpProviderId = "<sdp_provider_id>";

    type EncounterInfoSession = {
      session_id?: string;
      status?: string;
      artifacts?: string[];
    };

    type EncounterInfoNote = {
      note_id?: string;
      created_at?: string;
      updated_at?: string;
      sessions?: EncounterInfoSession[];
    };

    type GetEncounterInfoResponse = {
      notes?: EncounterInfoNote[];
    };

    type ApiErrorResponse = {
      code?: number;
      message?: string;
    };

    const response = await fetch(
      `${BASE_URL}/api/v1/ambient/encounter/${emrEncounterId}/info`,
      {
        method: "GET",
        headers: {
          sdp_suki_token: sdpSukiToken,
          sdp_provider_id: sdpProviderId,
        },
      }
    );

    const responseText = await response.text();
    let responseBody: GetEncounterInfoResponse | ApiErrorResponse | unknown;

    try {
      responseBody = responseText ? JSON.parse(responseText) : {};
    } catch {
      console.error("Response was not JSON:");
      console.error(responseText);
      throw new Error("Get Encounter Info returned non-JSON response");
    }

    console.log("HTTP status:", response.status);
    console.log("Response body:", JSON.stringify(responseBody, null, 2));

    if (response.status === 200) {
      const payload = responseBody as GetEncounterInfoResponse;
      const notes = payload.notes || [];
      console.log(`Notes found: ${notes.length}`);

      for (const note of notes) {
        console.log("note_id:", note.note_id);
        console.log("created_at:", note.created_at);
        console.log("updated_at:", note.updated_at);

        for (const session of note.sessions || []) {
          console.log("  session_id:", session.session_id);
          console.log("  status:", session.status);
          console.log("  artifacts:", session.artifacts);
        }

        console.log(
          "Use note_id with Get Note Content, Get Note Context, and Get Note Structured Data."
        );
      }
    } else {
      const error = responseBody as ApiErrorResponse;
      console.error("Get Encounter Info failed.");
      console.error("code:", error.code);
      console.error("message:", error.message);
    }
    ```
  </Tab>
</Tabs>


## OpenAPI

````yaml GET /api/v1/ambient/encounter/{emr_encounter_id}/info
openapi: 3.0.1
info:
  title: Suki Developer Platform
  description: >-
    REST and WebSocket APIs for the Suki Developer Platform. Authenticate with
    Login or Register to obtain a Suki access token, then integrate ambient
    clinical documentation, form filling, transcription, and reference metadata
    endpoints.
  contact: {}
  version: '1.0'
servers:
  - url: https://sdp.suki.ai
    description: >-
      Production base URL for Suki Developer Platform REST APIs. WebSocket
      endpoints use the same host with `wss://`.
security:
  - SukiTokenAuth: []
paths:
  /api/v1/ambient/encounter/{emr_encounter_id}/info:
    get:
      tags:
        - /api/v1/ambient/encounter
      summary: Gets resolved note → session hierarchy for an EMR encounter.
      parameters:
        - $ref: '#/components/parameters/ProviderIdHeader'
        - name: emr_encounter_id
          in: path
          required: true
          description: >-
            EMR encounter id (UUID or non-UUID, at most 36 characters). Same
            value you pass as `emr_encounter_id` on Ambient session create for
            interoperable workflows.
          schema:
            type: string
            maxLength: 36
      responses:
        '200':
          description: Success Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/controllers.GetEncounterInfoResponse'
        '400':
          description: Bad Request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/controllers.BadRequestError'
        '401':
          description: Unauthorized
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/controllers.AuthenticationError'
        '404':
          description: Not Found
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/controllers.NotFoundError'
        '500':
          description: Internal Server Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/controllers.InternalServerError'
      security:
        - SukiTokenAuth: []
components:
  parameters:
    ProviderIdHeader:
      name: sdp_provider_id
      in: header
      description: >-
        **Optional** for standard partners.


        **Required** for:


        - **Bearer authentication.** Use the same `provider_id` returned by the
        Login or Register API.

        - **Single Auth Token authentication.** Include the same `provider_id`
        on every request as `sdp_provider_id`.
      required: false
      schema:
        type: string
        example: provider-123
  schemas:
    controllers.GetEncounterInfoResponse:
      description: Resolved note → session hierarchy for an EMR encounter.
      type: object
      properties:
        notes:
          description: Notes with sessions and artifact availability for the EMR encounter.
          type: array
          items:
            $ref: '#/components/schemas/controllers.EncounterInfoNote'
    controllers.BadRequestError:
      description: Bad Request Response
      type: object
      properties:
        code:
          type: integer
          example: 400
        message:
          type: string
          example: invalid request
    controllers.AuthenticationError:
      description: Authentication Failure Response
      type: object
      properties:
        code:
          type: integer
          example: 401
        message:
          type: string
          example: invalid token
    controllers.NotFoundError:
      description: Not Found Response
      type: object
      properties:
        code:
          type: integer
          example: 404
        message:
          type: string
          example: not found
    controllers.InternalServerError:
      description: Internal Server Error Response
      type: object
      properties:
        code:
          type: integer
          example: 500
        message:
          type: string
          example: internal server error
    controllers.EncounterInfoNote:
      description: Note metadata and related sessions for an encounter.
      type: object
      properties:
        note_id:
          type: string
          description: Note identifier (use with note-level APIs).
        created_at:
          type: string
          format: date-time
          description: Note creation time (RFC3339).
        updated_at:
          type: string
          format: date-time
          description: Note last-update time (RFC3339); unset for signed notes (immutable).
        sessions:
          type: array
          description: Sessions associated with this note.
          items:
            $ref: '#/components/schemas/controllers.EncounterInfoSession'
    controllers.EncounterInfoSession:
      description: Session identifier, status, and available artifacts.
      type: object
      properties:
        session_id:
          type: string
          description: Ambient session ID (job owner identifier).
        status:
          type: string
          description: job.Status enum name (for example "COMPLETED").
        artifacts:
          type: array
          items:
            type: string
          description: >-
            Available session artifacts. Allowed values (v1): "transcript",
            "recording", "content". Omitted when unavailable.
  securitySchemes:
    SukiTokenAuth:
      type: apiKey
      in: header
      name: sdp_suki_token
      description: >-
        Suki access token (`suki_token`) from Login or Register. Expires after
        one hour.

````