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

# Medication Order Statuses

> Get supported medication order statuses

Use this endpoint to get the list of supported medication order statuses.

## Code examples

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

    url = "https://sdp.suki-stage.com/api/v1/info/orders/statuses"
    headers = {
        "sdp_suki_token": "<sdp_suki_token>",
        "sdp_provider_id": "<sdp_provider_id>"
    }

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

    if response.status_code == 200:
        statuses_data = response.json()
        print("Supported Medication Order Statuses:")
        for item in statuses_data.get("statuses", []):
            print(f"  {item.get('code')}")
    else:
        print(f"Failed to get medication order statuses: {response.status_code}")
        print(response.json())
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript theme={"theme":{"light":"github-dark","dark":"material-theme-darker"}}
    const response = await fetch('https://sdp.suki-stage.com/api/v1/info/orders/statuses', {
      headers: {
        'sdp_suki_token': '<sdp_suki_token>',
        'sdp_provider_id': '<sdp_provider_id>'
      }
    });

    if (response.ok) {
      const statusesData = await response.json();
      console.log('Supported Medication Order Statuses:');
      statusesData.statuses?.forEach((item: any) => {
        console.log(`  ${item.code}`);
      });
    } else {
      const error = await response.json();
      console.error(`Failed to get medication order statuses: ${response.status}`, error);
    }
    ```
  </Tab>
</Tabs>


## OpenAPI

````yaml GET /api/v1/info/orders/statuses
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/info/orders/statuses:
    get:
      tags:
        - /api/v1/info
      summary: Get medication order statuses
      description: Returns supported status values for medication orders.
      parameters:
        - $ref: '#/components/parameters/ProviderIdHeader'
      responses:
        '200':
          description: Request succeeded.
          content:
            '*/*':
              schema:
                $ref: >-
                  #/components/schemas/controllers.MedicationOrderStatusesResponse
        '401':
          description: Unauthorized. The Suki access token is missing, expired, or invalid.
          content:
            '*/*':
              schema:
                $ref: '#/components/schemas/controllers.AuthenticationError'
        '403':
          description: Forbidden. The authenticated user cannot access this resource.
          content:
            '*/*':
              schema:
                $ref: '#/components/schemas/controllers.ForbiddenError'
      security:
        - SukiTokenAuth: []
      x-codeSamples:
        - lang: bash
          label: cURL
          source: |-
            curl --request GET \
              --url https://sdp.suki.ai/api/v1/info/orders/statuses \
              --header 'sdp_suki_token: <sdp_suki_token>' \
              --header 'sdp_provider_id: <sdp_provider_id>'
components:
  parameters:
    ProviderIdHeader:
      name: sdp_provider_id
      in: header
      description: >-
        **Optional** - Stable identifier for the active provider. Omit for
        standard partners whose `partner_token` identifies the user.
        **Required** for Bearer partners and Single Auth Token authentication
        where multiple providers share one `partner_token`. Use the same
        `provider_id` you sent on Login or Register.
      required: false
      schema:
        type: string
        example: provider-123
  schemas:
    controllers.MedicationOrderStatusesResponse:
      description: Response body for the /info/orders/statuses endpoint
      type: object
      properties:
        statuses:
          description: Information about supported medication order statuses
          type: array
          items:
            $ref: '#/components/schemas/controllers.MedicationOrderStatusInfo'
    controllers.AuthenticationError:
      type: object
      properties:
        code:
          type: integer
          example: 401
          description: HTTP status code for the error.
        message:
          type: string
          example: invalid token
          description: Human-readable description of the authentication failure.
      description: Error response when authentication fails.
    controllers.ForbiddenError:
      type: object
      properties:
        code:
          type: integer
          example: 403
          description: HTTP status code for the error.
        message:
          type: string
          example: forbidden
          description: Human-readable description of the authorization failure.
      description: Error response when the caller lacks permission.
    controllers.MedicationOrderStatusInfo:
      description: Information about a medication order status
      type: object
      properties:
        code:
          description: Medication order status code (e.g., "ACTIVE", "DISCONTINUED")
          type: string
          example: ACTIVE
  securitySchemes:
    SukiTokenAuth:
      type: apiKey
      in: header
      name: sdp_suki_token
      description: >-
        Suki access token for the authenticated provider. Obtain this by calling
        Login or Register with a valid `partner_token`. Pass the `suki_token`
        value from the JSON response as the `sdp_suki_token` header on REST
        requests and non-browser WebSocket upgrades. Browser WebSocket clients
        pass the token in `Sec-WebSocket-Protocol` instead. Tokens expire after
        one hour; call Login again to refresh.

````