> ## 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.

# Get Note Content

> Retrieve accumulated Ambient note section content, including the latest edits

Use this endpoint to get accumulated section content across ambient sessions in a note.

If clinicians edit sections in a headed product such as the Web SDK, the response returns the **latest edited** section content. Use `composition_id` from [Create ambient session](/api-reference/ambient-sessions/create) as `note_id`.

<Tip>
  Prefer this endpoint when clinicians edit the note in the other headed products and you need the latest section content in your integration. Session-scoped content endpoints return content for a single ambient session only.
</Tip>

## Code examples

<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"

    # Use composition_id from Create Ambient Session as note_id
    note_id = "<composition_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/note/{note_id}/content"

    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:
        summary = response_body.get("summary") or []
        print(f"Sections found: {len(summary)}")

        for section in summary:
            print("title:", section.get("title"))
            print("loinc_code:", section.get("loinc_code"))
            print("content:", section.get("content"))
            print("source_transcripts:", section.get("source_transcripts"))
    else:
        print("Get Note Content 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";

    // Use composition_id from Create Ambient Session as note_id
    const noteId = "<composition_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 ContentBlock = {
      title?: string;
      loinc_code?: string;
      content?: string;
      source_transcripts?: string[];
    };

    type GetNoteContentResponse = {
      summary?: ContentBlock[];
    };

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

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

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

    try {
      responseBody = responseText ? JSON.parse(responseText) : {};
    } catch {
      console.error("Response was not JSON:");
      console.error(responseText);
      throw new Error("Get Note Content 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 GetNoteContentResponse;
      const summary = payload.summary || [];
      console.log(`Sections found: ${summary.length}`);

      for (const section of summary) {
        console.log("title:", section.title);
        console.log("loinc_code:", section.loinc_code);
        console.log("content:", section.content);
        console.log("source_transcripts:", section.source_transcripts);
      }
    } else {
      const error = responseBody as ApiErrorResponse;
      console.error("Get Note Content failed.");
      console.error("code:", error.code);
      console.error("message:", error.message);
    }
    ```
  </Tab>
</Tabs>


## OpenAPI

````yaml GET /api/v1/ambient/note/{note_id}/content
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/note/{note_id}/content:
    get:
      tags:
        - /api/v1/ambient/note
      summary: Gets the content for a note.
      parameters:
        - $ref: '#/components/parameters/ProviderIdHeader'
        - name: note_id
          in: path
          required: true
          description: >-
            Note identifier. Use the `composition_id` returned from Ambient
            session create (same value as note ID for note-level APIs).
          schema:
            type: string
      responses:
        '200':
          description: Success Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/controllers.GetNoteContentResponse'
        '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.GetNoteContentResponse:
      description: >-
        Accumulated note content across sessions in the note. For sections that
        were edited (for example in Web SDK), returns the latest edited section
        content.
      type: object
      properties:
        summary:
          description: >-
            Summary of the note (section content blocks rendered from the
            composition).
          type: array
          items:
            $ref: '#/components/schemas/controllers.ContentBlock'
    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.ContentBlock:
      type: object
      properties:
        content:
          description: >-
            The body of the content block usually refers to the content of the
            section.
          type: string
          example: Asthma exacerbation
        loinc_code:
          description: The LOINC code of the content block.
          type: string
          example: 18776-5
        source_transcripts:
          description: The source transcripts that were used to generate the content block.
          type: array
          items:
            type: string
          example:
            - asthma
            - exacerbation
        title:
          description: The title of the content block usually refers to section name.
          type: string
          example: ASSESSMENT AND PLAN
  securitySchemes:
    SukiTokenAuth:
      type: apiKey
      in: header
      name: sdp_suki_token
      description: >-
        Suki access token (`suki_token`) from Login or Register. Expires after
        one hour.

````