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

# Create Note

> Creates a new note



## OpenAPI

````yaml POST /v1/notes
openapi: 3.1.0
info:
  title: Sully API
  description: >
    The Sully API is a robust platform designed to empower healthcare technology
    companies and Electronic Health Record (EHR) vendors by integrating advanced
    AI-driven clinical capabilities to help save healthcare providers (HCPs)
    time and make better decisions.


    ## V2 Audio Transcriptions


    The V2 Audio Transcriptions API provides enhanced audio transcription
    services using advanced AI models with improved accuracy and language
    support.


    ### Authentication


    The API uses API key authentication. You must include both:

    - `X-API-Key`: Your API key

    - `X-Account-Id`: Your account identifier


    ### Rate Limiting


    The API implements rate limiting to ensure fair usage. Rate limit
    information is returned in response headers:

    - `X-RateLimit-Limit`: Maximum requests allowed

    - `X-RateLimit-Remaining`: Remaining requests in current window

    - `X-RateLimit-Reset`: When the rate limit resets


    ### Audio File Support


    Supported audio formats:

    - WAV (audio/wav, audio/wave, audio/x-wav)

    - MP3 (audio/mpeg, audio/mp3)

    - FLAC (audio/flac)

    - OGG (audio/ogg)

    - WebM (audio/webm)

    - MP4 (audio/mp4)

    - M4A (audio/m4a)

    - AAC (audio/aac)

    - Opus (audio/opus)


    Maximum file size: 100MB


    ### Language Support


    The API supports multiple languages, including:

    - English (en, en-US) with medical-optimized transcription

    - Spanish (es), German (de), French (fr), Hindi (hi), Italian (it), Japanese
    (ja), Dutch (nl), Portuguese (pt), and Russian (ru)

    - Additional support for languages including Chinese, Korean, and others


    ### Processing


    V2 Transcriptions are processed asynchronously:

    1. Upload returns immediately with `pending` status

    2. Processing happens in the background

    3. Status updates to `processing`, then `completed` or `failed`

    4. Webhook notifications are sent when processing completes (if configured)


    ### Dictation


    V2 transcriptions support an optional `dictation` boolean field.

    When enabled, the transcript is formatted for dictation-style output.

    The default is `false`.
  version: 0.2.0
servers:
  - url: https://api.sully.ai
    description: Sully Production API
  - url: https://api-testing.sully.ai
    description: Sully Testing API
security:
  - apiKeyAuth: []
    accountIdAuth: []
tags:
  - name: Notes
    description: >-
      Operations for creating and managing clinical notes from medical
      encounters
  - name: Note Styles
    description: Operations for managing templates and formatting styles for clinical notes
  - name: Audio Transcriptions
    description: >-
      Operations for converting medical audio to text, including streaming
      capability
  - name: V2 Transcriptions
    description: >
      V2 Audio transcription operations with enhanced features


      The V2 Transcriptions API allows you to convert audio files to text using
      advanced AI models.

      Features include:

      - Multi-language support with specialized medical models

      - Speaker diarization (identifying different speakers)

      - Word-level timestamps and confidence scores

      - Automatic audio format conversion

      - Optional dictation-oriented transcript formatting

      - Asynchronous processing with webhook notifications
  - name: Utilities
    description: Utility operations for transforming and processing medical data
  - name: Codings
    description: >-
      Operations for medical coding analysis including ICD-10 and CPT code
      extraction
  - name: Macros
    description: >-
      Operations for detecting and expanding text macros in medical
      documentation
paths:
  /v1/notes:
    post:
      tags:
        - Notes
      summary: Create a new clinical note
      description: Creates a new note
      operationId: createNote
      requestBody:
        description: Note to add
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateNotePayload'
        required: true
      responses:
        '200':
          description: Note response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/CreateNoteResponse'
        '400':
          description: unexpected error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  schemas:
    CreateNotePayload:
      type: object
      required:
        - transcript
      properties:
        transcript:
          type: string
          description: The raw medical transcript text to be processed into a clinical note
          example: >-
            Hey, how's it going? Good good yeah, so what's going on? Yeah, hi
            I'm Edward yeah hi hi Edward. How's it going? Yeah, good good. So
            I've been having a couple of issues like my back pain and knee pain.
        date:
          type: string
          description: >-
            Date of the patient encounter in ISO format (YYYY-MM-DD) or ISO
            datetime format (YYYY-MM-DDTHH:mm:ssZ)
          examples:
            date_only: '2024-11-07'
            datetime: '2024-11-07T21:24:51Z'
          pattern: ^(\d{4}-\d{2}-\d{2}|\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)$
        language:
          type: string
          enum:
            - en
            - es
            - fr
            - de
            - it
            - pt
            - ru
            - zh
          default: en
          description: >-
            Language code for the transcript content. While multiple languages
            are supported,  English ('en') is recommended for optimal output
            quality and accuracy.
          example: en
        noteType:
          type: object
          description: >-
            Configuration object specifying the style and format of the
            generated note
          properties:
            description:
              type: string
              description: A brief overview of the note.
            type:
              type: string
              description: >-
                Determines the type of note to generate.

                - Use `note_style` to provide a note style string

                - Use `note_template` to provide a [Note
                Template](/api-reference/schemas/note-template) payload

                - Use `soap` for the default SOAP template
              enum:
                - soap
                - note_style
                - note_template
              default: soap
              example: note_style
            template:
              oneOf:
                - type: string
                - type: object
              description: >-
                Custom template to generate the note. This is applicable only
                when `type`  is set to `note_style` or `note_template`.

                - When `type` is `note_style`, this is a note style string

                - When `type` is `note_template`, this is a [Note
                Template](/api-reference/schemas/note-template) payload
              example: >-
                write a standard clinical SOAP note with the following sections:
                - **Subjective**: Contains detailed HPI. - **Objective**:
                Contains PE and ROS. - **Assessment**: Contains differential
                diagnoses with corresponding plans. - **Patient Instructions**:
                Contains a list of instructions for the patient.
            includeJson:
              type: boolean
              description: >-
                Determines whether to include a JSON payload in the custom note
                output.  This option is applicable only for custom notes and
                defaults to `false`.  Enabling this will increase latency and
                payload size.
              default: false
              example: true
        patientInfo:
          type: object
          description: Optional patient information
          properties:
            name:
              type: string
              description: Patient's full name
            dateOfBirth:
              type: string
              format: date
              description: Patient's date of birth in ISO-8601 format (YYYY-MM-DD)
            gender:
              type: string
              description: Patient's gender identity
              enum:
                - male
                - female
                - other
                - prefer not to say
                - unspecified
        previousNote:
          type: string
          description: >-
            Reference to a previous note if this is a follow-up. This field is
            optional.
        context:
          type: string
          nullable: true
          description: Additional context for note generation. This field is optional.
        instructions:
          type: array
          items:
            type: string
          nullable: true
          description: Special instructions for note generation. This field is optional.
          example:
            - Use a professional and concise tone.
            - Include key details without unnecessary elaboration.
            - Ensure clarity for a general audience.
        medicationList:
          type: string
          description: >-
            List of up to 50 medications (comma separated) to use as reference
            for fixing spelling errors. This field is optional.
    CreateNoteResponse:
      type: object
      properties:
        status:
          type: string
          example: ok
          description: Status of the response
        data:
          type: object
          properties:
            noteId:
              type: string
              example: note_EXAMPLE123456789
              description: Unique identifier for the created note
        date:
          type: string
          format: date-time
          example: '2024-11-07T21:24:51.000Z'
          description: Timestamp of the response
    Error:
      required:
        - error
        - message
      type: object
      properties:
        error:
          type: integer
          format: int32
        message:
          type: string
  securitySchemes:
    apiKeyAuth:
      type: apiKey
      in: header
      name: X-API-KEY
    accountIdAuth:
      type: apiKey
      in: header
      name: X-ACCOUNT-ID

````