---
updatedAt: 2026-07-21T08:40:48.000Z
agentTools:
  projectIndex: https://developers.intandem.tech/llms.txt
---

# Create an AudioTranscription

## Overview
Transcribe audio files using multiple providers (OpenAI Whisper, OpenAI GPT-4o Transcribe, Google Chirp). Supports file upload via multipart form data.

### Supported Models
| Provider | Models |
|----------|--------|
| OpenAI | `openai/whisper-1`, `openai/gpt-4o-transcribe` |
| Google | `google/chirp-2` |

### Async Mode
Set `async: true` to queue the transcription and receive a run UID. Poll `GET /v3/ai/transcription_runs/{uid}` for the result. Recommended for long audio files or diarization.

**Available for Staff tokens**

# OpenAPI definition

```json
{
  "openapi": "3.1.0",
  "info": {
    "title": "Ai",
    "description": "Unified OpenAPI specification for ai domain",
    "version": "3.0",
    "x-generated": {
      "sourceFiles": [
        "recommendations.json",
        "business_rules.json",
        "business_ai_settings.json",
        "bizai.json",
        "ai_smart_reply.json",
        "generic_ai.json",
        "staff_ai_settings.json",
        "ai_generation_feedback.json"
      ],
      "pathNormalizations": [],
      "pathConflicts": [],
      "componentConflicts": [
        {
          "type": "schema",
          "name": "ErrorResponse",
          "resolution": "Renamed to ErrorResponse_business_rules",
          "files": [
            "merged",
            "business_rules.json"
          ]
        },
        {
          "type": "schema",
          "name": "ErrorResponse",
          "resolution": "Renamed to ErrorResponse_business_ai_settings",
          "files": [
            "merged",
            "business_ai_settings.json"
          ]
        },
        {
          "type": "schema",
          "name": "Response",
          "resolution": "Renamed to Response_ai_smart_reply",
          "files": [
            "merged",
            "ai_smart_reply.json"
          ]
        },
        {
          "type": "schema",
          "name": "ErrorResponse",
          "resolution": "Renamed to ErrorResponse_staff_ai_settings",
          "files": [
            "merged",
            "staff_ai_settings.json"
          ]
        }
      ],
      "totalPaths": 20,
      "totalComponents": 33
    }
  },
  "servers": [
    {
      "url": "https://api.vcita.biz",
      "description": "Unified API Gateway server"
    }
  ],
  "paths": {
    "/v3/ai/audio_transcriptions": {
      "post": {
        "tags": [
          "AI Audio Transcriptions"
        ],
        "summary": "Create an AudioTranscription",
        "description": "## Overview\nTranscribe audio files using multiple providers (OpenAI Whisper, OpenAI GPT-4o Transcribe, Google Chirp). Supports file upload via multipart form data.\n\n### Supported Models\n| Provider | Models |\n|----------|--------|\n| OpenAI | `openai/whisper-1`, `openai/gpt-4o-transcribe` |\n| Google | `google/chirp-2` |\n\n### Async Mode\nSet `async: true` to queue the transcription and receive a run UID. Poll `GET /v3/ai/transcription_runs/{uid}` for the result. Recommended for long audio files or diarization.\n\n**Available for Staff tokens**",
        "requestBody": {
          "required": true,
          "content": {
            "multipart/form-data": {
              "schema": {
                "type": "object",
                "properties": {
                  "file": {
                    "type": "string",
                    "format": "binary",
                    "description": "Audio file to transcribe (max 25MB). Supported formats: mp3, mp4, m4a, wav, webm, flac, ogg."
                  },
                  "model": {
                    "type": "string",
                    "description": "Model identifier in provider/model format (e.g., \"openai/gpt-4o-transcribe\", \"openai/whisper-1\", \"google/chirp-2\").",
                    "example": "openai/gpt-4o-transcribe"
                  },
                  "language": {
                    "type": "string",
                    "description": "ISO-639-1 language code for the audio content (e.g., \"en\" for English, \"es\" for Spanish, \"he\" for Hebrew). When omitted, the provider will auto-detect the language."
                  },
                  "prompt": {
                    "type": "string",
                    "description": "Optional guiding prompt to improve transcription accuracy. Useful for providing context, domain-specific terminology, or correcting recurring misrecognitions."
                  },
                  "response_format": {
                    "type": "string",
                    "enum": [
                      "json",
                      "text",
                      "srt",
                      "verbose_json",
                      "vtt"
                    ],
                    "description": "Desired response format. 'json' returns a simple JSON with text, 'text' returns plain text, 'srt' returns SubRip subtitle format, 'verbose_json' returns detailed JSON with word-level timestamps, 'vtt' returns WebVTT subtitle format. Defaults to 'json'."
                  },
                  "temperature": {
                    "type": "number",
                    "minimum": 0,
                    "maximum": 1,
                    "description": "Sampling temperature between 0 and 1. Higher values make the output more random, while lower values make it more deterministic. Defaults to 0."
                  },
                  "async": {
                    "type": "boolean",
                    "description": "Process the request asynchronously. Returns a run UID immediately that can be polled via GET /v3/ai/transcription_runs/{uid}. Recommended for long audio files or when diarization is needed.",
                    "default": false
                  }
                },
                "required": [
                  "file",
                  "model"
                ]
              }
            }
          }
        },
        "responses": {
          "200": {
            "description": "Successful transcription.",
            "content": {
              "application/json": {
                "schema": {
                  "allOf": [
                    {
                      "type": "object",
                      "properties": {
                        "success": {
                          "type": "boolean",
                          "description": "Indicates whether the API request was successful (true) or failed (false)."
                        },
                        "data": {
                          "type": "object",
                          "description": "The response payload. Present on successful responses (success: true)."
                        },
                        "error": {
                          "type": "string",
                          "description": "Error message for simple error responses. Used in some legacy endpoints."
                        },
                        "errors": {
                          "type": "array",
                          "description": "Array of error objects for detailed error responses. Present on error responses (success: false).",
                          "items": {
                            "type": "object",
                            "properties": {
                              "code": {
                                "type": "string",
                                "description": "Machine-readable error code (e.g., 'already_exists', 'invalid', 'not_found')."
                              },
                              "message": {
                                "type": "string",
                                "description": "Human-readable error message."
                              },
                              "field": {
                                "type": "string",
                                "description": "The field that caused the error (for validation errors)."
                              }
                            },
                            "required": [
                              "code",
                              "message"
                            ]
                          }
                        }
                      },
                      "required": [
                        "success"
                      ],
                      "description": "Generic wrapper object for API responses. Success responses contain 'data', while error responses contain 'errors' array or 'error' string."
                    },
                    {
                      "properties": {
                        "data": {
                          "type": "object",
                          "description": "Represents an audio transcription result, following the OpenAI Whisper API response format. Contains the transcribed text along with optional metadata such as detected language, audio duration, word-level timestamps, and segment-level data.",
                          "properties": {
                            "text": {
                              "type": "string",
                              "readOnly": true,
                              "description": "The full transcribed text output from the audio file."
                            },
                            "language": {
                              "type": "string",
                              "readOnly": true,
                              "description": "The detected or specified language code in ISO-639-1 format (e.g., \"en\" for English, \"es\" for Spanish, \"he\" for Hebrew)."
                            },
                            "duration": {
                              "type": "number",
                              "readOnly": true,
                              "description": "Total duration of the audio file in seconds (e.g., 3.5)."
                            },
                            "words": {
                              "type": "array",
                              "readOnly": true,
                              "description": "Word-level timestamps for each transcribed word. Only present when using the 'verbose_json' response format.",
                              "items": {
                                "type": "object",
                                "properties": {
                                  "word": {
                                    "type": "string",
                                    "description": "The transcribed word."
                                  },
                                  "start": {
                                    "type": "number",
                                    "description": "Start time of the word in seconds from the beginning of the audio."
                                  },
                                  "end": {
                                    "type": "number",
                                    "description": "End time of the word in seconds from the beginning of the audio."
                                  }
                                }
                              }
                            },
                            "segments": {
                              "type": "array",
                              "readOnly": true,
                              "description": "Segment-level data with timing and optional speaker information. Each segment represents a contiguous block of transcribed speech, useful for diarization and long audio files.",
                              "items": {
                                "type": "object",
                                "properties": {
                                  "id": {
                                    "type": "integer",
                                    "description": "Sequential identifier for the segment (e.g., 0, 1, 2)."
                                  },
                                  "start": {
                                    "type": "number",
                                    "description": "Start time of the segment in seconds from the beginning of the audio."
                                  },
                                  "end": {
                                    "type": "number",
                                    "description": "End time of the segment in seconds from the beginning of the audio."
                                  },
                                  "text": {
                                    "type": "string",
                                    "description": "The transcribed text for this segment."
                                  },
                                  "speaker": {
                                    "type": "string",
                                    "description": "Speaker identifier when diarization is enabled (e.g., \"SPEAKER_00\", \"SPEAKER_01\")."
                                  }
                                }
                              }
                            }
                          },
                          "required": [
                            "text"
                          ],
                          "example": {
                            "text": "For more information visit www.FEMA.gov",
                            "language": "en",
                            "duration": 3.5,
                            "words": [
                              {
                                "word": "For",
                                "start": 0,
                                "end": 0.18
                              },
                              {
                                "word": "more",
                                "start": 0.18,
                                "end": 0.38
                              },
                              {
                                "word": "information",
                                "start": 0.38,
                                "end": 0.92
                              },
                              {
                                "word": "visit",
                                "start": 0.92,
                                "end": 1.24
                              },
                              {
                                "word": "www.FEMA.gov",
                                "start": 1.24,
                                "end": 3.5
                              }
                            ],
                            "segments": [
                              {
                                "id": 0,
                                "start": 0,
                                "end": 3.5,
                                "text": "For more information visit www.FEMA.gov",
                                "speaker": "SPEAKER_00"
                              }
                            ]
                          }
                        }
                      }
                    }
                  ]
                }
              }
            }
          },
          "202": {
            "description": "Async mode: job queued successfully. Poll the returned run UID for the result.",
            "content": {
              "application/json": {
                "schema": {
                  "allOf": [
                    {
                      "type": "object",
                      "properties": {
                        "success": {
                          "type": "boolean",
                          "description": "Indicates whether the API request was successful (true) or failed (false)."
                        },
                        "data": {
                          "type": "object",
                          "description": "The response payload. Present on successful responses (success: true)."
                        },
                        "error": {
                          "type": "string",
                          "description": "Error message for simple error responses. Used in some legacy endpoints."
                        },
                        "errors": {
                          "type": "array",
                          "description": "Array of error objects for detailed error responses. Present on error responses (success: false).",
                          "items": {
                            "type": "object",
                            "properties": {
                              "code": {
                                "type": "string",
                                "description": "Machine-readable error code (e.g., 'already_exists', 'invalid', 'not_found')."
                              },
                              "message": {
                                "type": "string",
                                "description": "Human-readable error message."
                              },
                              "field": {
                                "type": "string",
                                "description": "The field that caused the error (for validation errors)."
                              }
                            },
                            "required": [
                              "code",
                              "message"
                            ]
                          }
                        }
                      },
                      "required": [
                        "success"
                      ],
                      "description": "Generic wrapper object for API responses. Success responses contain 'data', while error responses contain 'errors' array or 'error' string."
                    },
                    {
                      "properties": {
                        "data": {
                          "type": "object",
                          "description": "Represents an async transcription run. Poll this resource until status is COMPLETED or FAILED.",
                          "properties": {
                            "uid": {
                              "type": "string",
                              "readOnly": true,
                              "description": "Unique identifier of the transcription run."
                            },
                            "status": {
                              "type": "string",
                              "readOnly": true,
                              "enum": [
                                "QUEUED",
                                "IN_PROGRESS",
                                "COMPLETED",
                                "FAILED"
                              ],
                              "description": "Current status of the run. Possible values: 'QUEUED' (job is waiting to be processed), 'IN_PROGRESS' (job is actively being processed by the transcription provider), 'COMPLETED' (job finished successfully and result is available), 'FAILED' (job encountered an error and error_message is available)."
                            },
                            "created_at": {
                              "type": "string",
                              "format": "date-time",
                              "readOnly": true,
                              "description": "The date and time when the run was created, in ISO 8601 format (e.g., \"2026-02-08T13:18:39.698Z\")."
                            },
                            "updated_at": {
                              "type": "string",
                              "format": "date-time",
                              "readOnly": true,
                              "description": "The date and time when the run was last updated, in ISO 8601 format (e.g., \"2026-02-08T13:18:41.000Z\")."
                            },
                            "result": {
                              "type": "object",
                              "description": "The transcription result. Only present when status is 'COMPLETED'.",
                              "properties": {
                                "text": {
                                  "type": "string",
                                  "readOnly": true,
                                  "description": "The full transcribed text output from the audio file."
                                },
                                "language": {
                                  "type": "string",
                                  "readOnly": true,
                                  "description": "The detected or specified language code in ISO-639-1 format (e.g., \"en\" for English, \"es\" for Spanish, \"he\" for Hebrew)."
                                },
                                "duration": {
                                  "type": "number",
                                  "readOnly": true,
                                  "description": "Total duration of the audio file in seconds (e.g., 3.5)."
                                },
                                "words": {
                                  "type": "array",
                                  "readOnly": true,
                                  "description": "Word-level timestamps for each transcribed word. Only present when using the 'verbose_json' response format.",
                                  "items": {
                                    "type": "object",
                                    "properties": {
                                      "word": {
                                        "type": "string",
                                        "description": "The transcribed word."
                                      },
                                      "start": {
                                        "type": "number",
                                        "description": "Start time of the word in seconds from the beginning of the audio."
                                      },
                                      "end": {
                                        "type": "number",
                                        "description": "End time of the word in seconds from the beginning of the audio."
                                      }
                                    }
                                  }
                                },
                                "segments": {
                                  "type": "array",
                                  "readOnly": true,
                                  "description": "Segment-level data with timing and optional speaker information. Each segment represents a contiguous block of transcribed speech, useful for diarization and long audio files.",
                                  "items": {
                                    "type": "object",
                                    "properties": {
                                      "id": {
                                        "type": "integer",
                                        "description": "Sequential identifier for the segment (e.g., 0, 1, 2)."
                                      },
                                      "start": {
                                        "type": "number",
                                        "description": "Start time of the segment in seconds from the beginning of the audio."
                                      },
                                      "end": {
                                        "type": "number",
                                        "description": "End time of the segment in seconds from the beginning of the audio."
                                      },
                                      "text": {
                                        "type": "string",
                                        "description": "The transcribed text for this segment."
                                      },
                                      "speaker": {
                                        "type": "string",
                                        "description": "Speaker identifier when diarization is enabled (e.g., \"SPEAKER_00\", \"SPEAKER_01\")."
                                      }
                                    }
                                  }
                                }
                              },
                              "required": [
                                "text"
                              ],
                              "example": {
                                "text": "For more information visit www.FEMA.gov",
                                "language": "en",
                                "duration": 3.5,
                                "words": [
                                  {
                                    "word": "For",
                                    "start": 0,
                                    "end": 0.18
                                  },
                                  {
                                    "word": "more",
                                    "start": 0.18,
                                    "end": 0.38
                                  },
                                  {
                                    "word": "information",
                                    "start": 0.38,
                                    "end": 0.92
                                  },
                                  {
                                    "word": "visit",
                                    "start": 0.92,
                                    "end": 1.24
                                  },
                                  {
                                    "word": "www.FEMA.gov",
                                    "start": 1.24,
                                    "end": 3.5
                                  }
                                ],
                                "segments": [
                                  {
                                    "id": 0,
                                    "start": 0,
                                    "end": 3.5,
                                    "text": "For more information visit www.FEMA.gov",
                                    "speaker": "SPEAKER_00"
                                  }
                                ]
                              },
                              "readOnly": true
                            },
                            "error_message": {
                              "type": "string",
                              "readOnly": true,
                              "description": "Error message describing the failure reason. Only present when status is 'FAILED'."
                            }
                          },
                          "required": [
                            "uid",
                            "status",
                            "created_at"
                          ],
                          "example": {
                            "uid": "85ade9f5-2690-48e8-ae5b-b07d6b57b457",
                            "status": "COMPLETED",
                            "created_at": "2026-02-08T13:18:39.698Z",
                            "updated_at": "2026-02-08T13:18:41.000Z",
                            "result": {
                              "text": "For more information visit www.FEMA.gov",
                              "language": "en",
                              "duration": 3.5
                            }
                          }
                        }
                      }
                    }
                  ]
                }
              }
            }
          },
          "400": {
            "description": "Bad Request - The request is malformed or contains invalid syntax.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "success": {
                      "type": "boolean",
                      "description": "Indicates whether the API request was successful (true) or failed (false)."
                    },
                    "data": {
                      "type": "object",
                      "description": "The response payload. Present on successful responses (success: true)."
                    },
                    "error": {
                      "type": "string",
                      "description": "Error message for simple error responses. Used in some legacy endpoints."
                    },
                    "errors": {
                      "type": "array",
                      "description": "Array of error objects for detailed error responses. Present on error responses (success: false).",
                      "items": {
                        "type": "object",
                        "properties": {
                          "code": {
                            "type": "string",
                            "description": "Machine-readable error code (e.g., 'already_exists', 'invalid', 'not_found')."
                          },
                          "message": {
                            "type": "string",
                            "description": "Human-readable error message."
                          },
                          "field": {
                            "type": "string",
                            "description": "The field that caused the error (for validation errors)."
                          }
                        },
                        "required": [
                          "code",
                          "message"
                        ]
                      }
                    }
                  },
                  "required": [
                    "success"
                  ],
                  "description": "Generic wrapper object for API responses. Success responses contain 'data', while error responses contain 'errors' array or 'error' string."
                },
                "example": {
                  "success": false,
                  "errors": [
                    {
                      "code": "invalid_syntax",
                      "message": "Request body is malformed or missing required multipart form data."
                    }
                  ]
                }
              }
            }
          },
          "401": {
            "description": "Unauthorized - The bearer token is missing, expired, or invalid.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "success": {
                      "type": "boolean",
                      "description": "Indicates whether the API request was successful (true) or failed (false)."
                    },
                    "data": {
                      "type": "object",
                      "description": "The response payload. Present on successful responses (success: true)."
                    },
                    "error": {
                      "type": "string",
                      "description": "Error message for simple error responses. Used in some legacy endpoints."
                    },
                    "errors": {
                      "type": "array",
                      "description": "Array of error objects for detailed error responses. Present on error responses (success: false).",
                      "items": {
                        "type": "object",
                        "properties": {
                          "code": {
                            "type": "string",
                            "description": "Machine-readable error code (e.g., 'already_exists', 'invalid', 'not_found')."
                          },
                          "message": {
                            "type": "string",
                            "description": "Human-readable error message."
                          },
                          "field": {
                            "type": "string",
                            "description": "The field that caused the error (for validation errors)."
                          }
                        },
                        "required": [
                          "code",
                          "message"
                        ]
                      }
                    }
                  },
                  "required": [
                    "success"
                  ],
                  "description": "Generic wrapper object for API responses. Success responses contain 'data', while error responses contain 'errors' array or 'error' string."
                },
                "example": {
                  "success": false,
                  "errors": [
                    {
                      "code": "unauthorized",
                      "message": "Invalid or expired bearer token."
                    }
                  ]
                }
              }
            }
          },
          "413": {
            "description": "Payload Too Large - The uploaded audio file exceeds the 25MB size limit.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "success": {
                      "type": "boolean",
                      "description": "Indicates whether the API request was successful (true) or failed (false)."
                    },
                    "data": {
                      "type": "object",
                      "description": "The response payload. Present on successful responses (success: true)."
                    },
                    "error": {
                      "type": "string",
                      "description": "Error message for simple error responses. Used in some legacy endpoints."
                    },
                    "errors": {
                      "type": "array",
                      "description": "Array of error objects for detailed error responses. Present on error responses (success: false).",
                      "items": {
                        "type": "object",
                        "properties": {
                          "code": {
                            "type": "string",
                            "description": "Machine-readable error code (e.g., 'already_exists', 'invalid', 'not_found')."
                          },
                          "message": {
                            "type": "string",
                            "description": "Human-readable error message."
                          },
                          "field": {
                            "type": "string",
                            "description": "The field that caused the error (for validation errors)."
                          }
                        },
                        "required": [
                          "code",
                          "message"
                        ]
                      }
                    }
                  },
                  "required": [
                    "success"
                  ],
                  "description": "Generic wrapper object for API responses. Success responses contain 'data', while error responses contain 'errors' array or 'error' string."
                },
                "example": {
                  "success": false,
                  "errors": [
                    {
                      "field": "file",
                      "code": "too_large",
                      "message": "File size exceeds the maximum allowed limit of 25MB."
                    }
                  ]
                }
              }
            }
          },
          "422": {
            "description": "Unprocessable Entity - Validation error with valid syntax.",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "success": {
                      "type": "boolean",
                      "description": "Indicates whether the API request was successful (true) or failed (false)."
                    },
                    "data": {
                      "type": "object",
                      "description": "The response payload. Present on successful responses (success: true)."
                    },
                    "error": {
                      "type": "string",
                      "description": "Error message for simple error responses. Used in some legacy endpoints."
                    },
                    "errors": {
                      "type": "array",
                      "description": "Array of error objects for detailed error responses. Present on error responses (success: false).",
                      "items": {
                        "type": "object",
                        "properties": {
                          "code": {
                            "type": "string",
                            "description": "Machine-readable error code (e.g., 'already_exists', 'invalid', 'not_found')."
                          },
                          "message": {
                            "type": "string",
                            "description": "Human-readable error message."
                          },
                          "field": {
                            "type": "string",
                            "description": "The field that caused the error (for validation errors)."
                          }
                        },
                        "required": [
                          "code",
                          "message"
                        ]
                      }
                    }
                  },
                  "required": [
                    "success"
                  ],
                  "description": "Generic wrapper object for API responses. Success responses contain 'data', while error responses contain 'errors' array or 'error' string."
                },
                "example": {
                  "success": false,
                  "errors": [
                    {
                      "field": "model",
                      "code": "invalid",
                      "message": "Unsupported model. Supported models: openai/whisper-1, openai/gpt-4o-transcribe, google/chirp-2."
                    }
                  ]
                }
              }
            }
          },
          "429": {
            "description": "Too Many Requests - Rate limit exceeded (10 requests per minute).",
            "content": {
              "application/json": {
                "schema": {
                  "type": "object",
                  "properties": {
                    "success": {
                      "type": "boolean",
                      "description": "Indicates whether the API request was successful (true) or failed (false)."
                    },
                    "data": {
                      "type": "object",
                      "description": "The response payload. Present on successful responses (success: true)."
                    },
                    "error": {
                      "type": "string",
                      "description": "Error message for simple error responses. Used in some legacy endpoints."
                    },
                    "errors": {
                      "type": "array",
                      "description": "Array of error objects for detailed error responses. Present on error responses (success: false).",
                      "items": {
                        "type": "object",
                        "properties": {
                          "code": {
                            "type": "string",
                            "description": "Machine-readable error code (e.g., 'already_exists', 'invalid', 'not_found')."
                          },
                          "message": {
                            "type": "string",
                            "description": "Human-readable error message."
                          },
                          "field": {
                            "type": "string",
                            "description": "The field that caused the error (for validation errors)."
                          }
                        },
                        "required": [
                          "code",
                          "message"
                        ]
                      }
                    }
                  },
                  "required": [
                    "success"
                  ],
                  "description": "Generic wrapper object for API responses. Success responses contain 'data', while error responses contain 'errors' array or 'error' string."
                },
                "example": {
                  "success": false,
                  "errors": [
                    {
                      "code": "rate_limit_exceeded",
                      "message": "Rate limit exceeded. Maximum 10 requests per minute. Please retry after 60 seconds."
                    }
                  ]
                }
              }
            }
          }
        },
        "security": [
          {
            "Bearer": []
          }
        ]
      }
    }
  },
  "components": {
    "securitySchemes": {
      "Bearer": {
        "type": "http",
        "scheme": "bearer",
        "bearerFormat": "JWT",
        "description": "Provide a valid bearer token in the Authorization header. Example: 'Authorization: Bearer {app_token}'"
      }
    }
  },
  "tags": [
    {
      "name": "AI Audio Transcriptions",
      "description": "Transcribe audio files using multiple providers"
    }
  ]
}
```