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

# Check Status and Retrieve Content

> Check ambient session processing status and retrieve clinical notes, transcripts, and structured data with the Mobile SDK

Check status and retrieve content lets you track when an ambient session finishes processing and pull the clinical note, transcript, and structured data for that `sessionId`.

## Check status and retrieve content

After you end a session, asynchronously check its processing status and retrieve the generated content. You must provide a valid `sessionId` for the session you want to query.

The diagram below illustrates the process of retrieving the generated content of a session.

```mermaid actions={false} theme={"theme":{"light":"one-light","dark":"material-theme-darker"}}
%%{init: {'theme':'base', 'themeVariables': { 'primaryColor':'#FFF394','primaryTextColor':'#1a1a1a','primaryBorderColor':'#FFE148','lineColor':'#FFE148','secondaryColor':'#FFE148','tertiaryColor':'#FFFADE','mainBkg':'#FFF394','secondBkg':'#FFFADE','tertiaryBorderColor':'#FFE148','border1':'#FFE148','border2':'#FFE148','arrowheadColor':'#FFE148','fontFamily':'Inter, system-ui, sans-serif','fontSize':'14px','nodeBorder':'#FFE148','edgeLabelBackground':'#FFE148','clusterBkg':'#FFFADE','clusterBorder':'#FFE148','defaultLinkColor':'#FFE148','titleColor':'#1a1a1a','nodeTextColor':'#1a1a1a'}}}%%
graph TD
    A[Start: You have a valid sessionId] --> B{Call a retrieval method, passing the ID}
    B --> C[SDK performs an asynchronous operation...]
    C --> D{Completion Handler is called with a Result}
    D -->|Success| E[Process the returned content<br/>e.g., display suggestions, transcript]
    D -->|Failure| F[Handle the returned error]
    E --> G[End]
    F --> G[End]

    style A fill:#FFF394,stroke:#FFE148,stroke-width:2px,color:#1a1a1a
    style B fill:#FFE148,stroke:#FFE148,stroke-width:2px,color:#1a1a1a
    style C fill:#FFF394,stroke:#FFE148,stroke-width:2px,color:#1a1a1a
    style D fill:#FFE148,stroke:#FFE148,stroke-width:2px,color:#1a1a1a
    style E fill:#FFF394,stroke:#FFE148,stroke-width:2px,color:#1a1a1a
    style F fill:#FFF394,stroke:#FFE148,stroke-width:2px,color:#1a1a1a
    style G fill:#FFF394,stroke:#FFE148,stroke-width:2px,color:#1a1a1a
```

All retrieval methods are **asynchronous**. The result is returned in a <Tooltip tip="A closure that runs when a task, such as a network request, is complete. Use it to process the final result or handle an error">
Completion handler
</Tooltip>, which provides either the requested content or an error.

### Check the processing status

Call `status(for:)` after a session ends to check whether Suki has finished processing the audio. The clinical note, transcript, and structured data are only available once processing is complete, so use this method to decide when to call the retrieval methods and to drive a "processing" or "note ready" state in your UI.

Suki needs at least **one minute of audio** to generate content. If a session was too short or is not yet complete, the status reflects that, and the retrieval methods return no content.

<CodeGroup>
  ```swift Swift theme={"theme":{"light":"one-light","dark":"material-theme-darker"}}
  SukiAmbientCoreManager.shared.status(for: sessionId) { result in
      // The completion handler returns a result type.
      switch result {
      case .success(let status):
          // On success, the status object contains the current state.
          print("Session status: \(status)")
      case .failure(let error):
          // On failure, an error object is returned.
          print("Error fetching status: \(error)")
      }
  }
  ```
</CodeGroup>

### Get generated suggestions

Call `content(for:)` to retrieve the AI-generated clinical note: the suggestions your provider reviews, edits, and signs before handoff to the EHR. This is the primary output most integrations display after a visit.

Call it only after `status(for:)` reports that processing is complete. Calling it earlier returns no content.

<CodeGroup>
  ```swift Swift theme={"theme":{"light":"one-light","dark":"material-theme-darker"}}
  SukiAmbientCoreManager.shared.content(for: sessionId) { result in
      switch result {
      case .success(let suggestions):
          // The suggestions object contains the generated note content.
          print("Generated Suggestions: \(suggestions)")
      case .failure(let error):
          print("Error fetching content: \(error)")
      }
  }
  ```
</CodeGroup>

### Get the audio transcript

Call `transcript(for:)` to retrieve the word-for-word text of the conversation, which is separate from the generated clinical note. Use it when you need exactly what was said rather than the summarized note, for example to let a provider verify the note against the transcript, support QA or compliance review, or display the transcript alongside the note.

The response contains transcript segments. The example below joins them into a single string.

<CodeGroup>
  ```swift Swift theme={"theme":{"light":"one-light","dark":"material-theme-darker"}}
  SukiAmbientCoreManager.shared.transcript(for: sessionId) { result in
      switch result {
      case .success(let response):
          // The response object contains transcript segments.
          // This example joins them into a single string.
          let transcriptText = (response.finalTranscript ?? []).compactMap { $0.transcript }.joined(separator: " ")
          print(transcriptText)
      case .failure(let error):
          print("Error fetching transcript: \(error)")
      }
  }
  ```
</CodeGroup>

### Get structured data

Call `getStructuredData(for:)` when you need discrete, machine-readable output instead of free-text notes, for example to populate diagnosis fields, drive orders, support medical coding, or feed analytics in your application. It returns diagnoses and other entities generated from the session.

<Note>
  Starting with Mobile SDK `v2.6.0`, the response may include Medication orders when that capability is enabled for your integration. Medication orders are **optional**, so check for them before you use them, as shown below.
</Note>

<CodeGroup>
  ```swift Swift theme={"theme":{"light":"one-light","dark":"material-theme-darker"}}
  SukiAmbientCoreManager.shared.getStructuredData(for: sessionId) { result in // [!code ++:19]
      switch result {
      case .success(let response):
          let data = response.structuredData
          // Diagnoses
          for d in data.diagnoses.diagnoses {
              print(d.note)
          }
          // Medication orders (optional) [!code ++:6] if Medication orders are enabled
          if let orders = data.orders?.medicationOrders {
              let all = orders.values + orders.partialValues
              for order in all {
                  print(order.drugName, order.instructions)
              }
          }
      case .failure(let error):
          print(error)
      }
  }
  ```
</CodeGroup>

## Next steps

<Icon icon="file-lines" iconType="solid" /> **[Session status and content retrieval](/mobile-sdk/ambient-guides/session-status-and-content-retrieval)** - overview of all retrieval workflows.

<Icon icon="file-lines" iconType="solid" /> **[Shared notes across products](/mobile-sdk/ambient-guides/shared-notes-across-products)** - List and read notes shared across Suki products.

<Icon icon="file-lines" iconType="solid" /> **[Clear session](/mobile-sdk/ambient-guides/clearing-sessions)** - Clear local session state after retrieve.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.