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

# Transcribe an audio file

> OpenAI-compatible bounded file transcription. Use `Authorization: Bearer
<API_KEY>` and `multipart/form-data`. The initial profile supports files up
to 25 MB and `json` or `verbose_json` responses. Unsupported OpenAI fields
are rejected explicitly.

The accepted model set is a curated per-environment allowlist that a model
joins only after passing contract qualification; `openai/whisper-large-v3`
is the launch model. Requesting a model outside the allowlist returns a 400
without dispatching audio.

This endpoint is independently feature-gated during preview rollout. A
disabled deployment returns an OpenAI-shaped 404 without dispatching audio.
It is synchronous and does not use prediction polling or streaming.




## OpenAPI

````yaml /openapi_specs/models.json post /v1/audio/transcriptions
openapi: 3.0.3
info:
  title: each::labs Official API v1
  description: >
    Official each::labs API V1.

    This API provides access to our comprehensive AI model catalog and other
    resources.


    ## Public contract notes


    - Public API routes handled by request logging include `X-Request-Id` for
      support and log correlation. Clients may send `X-Request-Id`; otherwise
      api-service generates one. Root, health, and metrics endpoints are excluded.
    - REST error bodies keep the backward-compatible JSON shape used by existing
      clients. Most errors include at least `error`; some shared error paths also
      include `status` and `details`. Use the HTTP status code as the primary
      programmatic signal unless an endpoint documents a richer envelope.
    - Rate-limit and retry headers are endpoint-dependent. If a response
    includes
      `Retry-After`, honor it before retrying; otherwise use bounded exponential
      backoff for retryable 429/5xx responses.
  version: 1.0.0
  contact:
    name: API Support
    email: support@eachlabs.ai
  x-logo:
    url: ./logo-white.svg
    altText: each::labs
servers:
  - url: https://api.eachlabs.ai
    description: Production server
security: []
tags:
  - name: AI Models
    description: Endpoints for listing and retrieving AI models and other resources.
  - name: AI Models Prediction
    description: Endpoints for managing model predictions
  - name: Uploads
    description: Endpoints for uploading files that can be used as model inputs.
  - name: Executions
    description: Endpoints for listing execution history.
  - name: Workflows
    description: >-
      Endpoints for creating workflows and triggering workflow executions
      through api-service.
  - name: OpenAI Compatibility
    description: OpenAI-compatible endpoints for LLM Router requests.
  - name: Webhooks
    description: >
      Endpoints for retrieving webhook information and delivery history.


      **Note:** Currently, webhooks are only supported for Workflows V2. We are
      actively expanding webhook support to other services and will update this
      documentation as new integrations become available.
paths:
  /v1/audio/transcriptions:
    post:
      tags:
        - OpenAI Compatibility
      summary: Transcribe an audio file
      description: >
        OpenAI-compatible bounded file transcription. Use `Authorization: Bearer

        <API_KEY>` and `multipart/form-data`. The initial profile supports files
        up

        to 25 MB and `json` or `verbose_json` responses. Unsupported OpenAI
        fields

        are rejected explicitly.


        The accepted model set is a curated per-environment allowlist that a
        model

        joins only after passing contract qualification;
        `openai/whisper-large-v3`

        is the launch model. Requesting a model outside the allowlist returns a
        400

        without dispatching audio.


        This endpoint is independently feature-gated during preview rollout. A

        disabled deployment returns an OpenAI-shaped 404 without dispatching
        audio.

        It is synchronous and does not use prediction polling or streaming.
      operationId: createAudioTranscription
      requestBody:
        required: true
        content:
          multipart/form-data:
            schema:
              $ref: '#/components/schemas/AudioTranscriptionRequest'
      responses:
        '200':
          description: OpenAI-compatible JSON transcription response
          headers:
            X-Generation-Id:
              description: Upstream generation identifier when available.
              schema:
                type: string
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/AudioTranscriptionResponse'
        '400':
          description: Invalid multipart input or unsupported field/model/format
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '401':
          description: Authentication failed
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '402':
          description: Insufficient balance
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '404':
          description: Capability disabled for this deployment
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '413':
          description: Audio file exceeds 25 MB
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '429':
          description: Provider rate limit reached
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '500':
          description: Server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '503':
          description: Authentication or transcription service temporarily unavailable
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
        '504':
          description: Transcription request timed out
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/OpenAIErrorResponse'
      security:
        - BearerAuth: []
components:
  schemas:
    AudioTranscriptionRequest:
      type: object
      required:
        - file
        - model
      properties:
        file:
          type: string
          format: binary
          description: FLAC, MP3/MPEG/MPGA, MP4/M4A, OGG, WAV, or WebM audio up to 25 MB.
        model:
          type: string
          example: openai/whisper-large-v3
          description: >-
            Must be in the environment's transcription allowlist. Requesting a
            model outside it returns 400 without dispatching audio.
        language:
          type: string
          maxLength: 32
          description: Optional ISO language code.
        response_format:
          type: string
          default: json
          enum:
            - json
            - verbose_json
        temperature:
          type: number
          minimum: 0
          maximum: 1
        timestamp_granularities[]:
          type: array
          description: >-
            Available only with `verbose_json`; repeat the multipart field for
            multiple values.
          items:
            type: string
            enum:
              - word
              - segment
    AudioTranscriptionResponse:
      type: object
      required:
        - text
      properties:
        text:
          type: string
        language:
          type: string
        duration:
          type: number
        segments:
          type: array
          items:
            type: object
            additionalProperties: true
        words:
          type: array
          items:
            type: object
            additionalProperties: true
        usage:
          type: object
          additionalProperties: true
    OpenAIErrorResponse:
      type: object
      description: >-
        OpenAI-compatible error envelope used by chat, audio, and realtime
        compatibility endpoints.
      properties:
        error:
          type: object
          properties:
            message:
              type: string
              example: Invalid API key
            type:
              type: string
              example: authentication_error
            param:
              type: string
              example: model
            code:
              type: string
              example: invalid_api_key
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      description: >-
        API key passed as an Authorization Bearer token: `Authorization: Bearer
        YOUR_API_KEY`

````