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

# Export logged exchanges as JSONL

> The filtered exchanges as JSONL — one `{"messages": [...]}` line each, request messages with the assistant reply appended. That's the chat format every training and eval pipeline accepts, so it pipes straight into your own tooling.

Capped at 10,000 rows; `X-Omnia-Export-Capped: true` means you hit the cap — narrow the filter (a time range works well) to page through the rest.



## OpenAPI

````yaml /openapi.json get /v1/logs/export
openapi: 3.1.0
info:
  title: Omnia Management API
  description: >-
    The management API behind the improvement loop: capture and setup, request
    logs and datasets, grades (labels), judges (criteria), evals and deploy
    gates, fine-tuning and reinforcement learning, dedicated GPU endpoints, and
    model aliases and versions. Authenticated with a workspace API key
    (sk_sovereign_...). The inference API (chat, embeddings, rerank, responses)
    is OpenAI-compatible and documented separately.


    Responses are snake_case, list endpoints on the loop products use the
    {"object": "list", "data": [...]} envelope, and refusals use the same nested
    error shape the gateway emits: {"error": {"message", "type", "code"}}.
    Request bodies on the loop products (logs, labels, criteria, evals,
    datasets, aliases) are snake_case; the training and infrastructure products
    (fine-tuning, GRPO, environment tools, dedicated, model-version adoption)
    validate camelCase bodies, and each schema below says which it is. Endpoints
    that spend money require a key minted by a workspace owner or admin and
    return 403 otherwise.
  version: 1.0.0
servers:
  - url: https://gateway.omnia-voice.com
    description: Production
  - url: https://platform.omnia-voice.com/api
    description: Production (legacy alias — same API, older base URL)
security:
  - bearerAuth: []
paths:
  /v1/logs/export:
    get:
      tags:
        - Logs
      summary: Export logged exchanges as JSONL
      description: >-
        The filtered exchanges as JSONL — one `{"messages": [...]}` line each,
        request messages with the assistant reply appended. That's the chat
        format every training and eval pipeline accepts, so it pipes straight
        into your own tooling.


        Capped at 10,000 rows; `X-Omnia-Export-Capped: true` means you hit the
        cap — narrow the filter (a time range works well) to page through the
        rest.
      operationId: exportLogs
      parameters:
        - name: model
          in: query
          schema:
            type: string
          description: Only exchanges served by this model.
        - name: tag
          in: query
          schema:
            type: string
          description: Only exchanges whose request carried this X-Omnia-Tag.
        - name: segment
          in: query
          schema:
            type: string
          description: >-
            Only exchanges in this auto-detected traffic segment (a `segment`
            value from a logs row — the family of system prompts sharing one
            template). Composes with tag: segments are detected, tags are
            declared.
        - name: finish_reason
          in: query
          schema:
            type: string
            enum:
              - stop
              - length
              - tool_calls
        - name: cache_hit
          in: query
          schema:
            type: boolean
          description: true = cache replays only; false = exclude them.
        - name: start
          in: query
          schema:
            type: integer
          description: Unix seconds, inclusive.
        - name: end
          in: query
          schema:
            type: integer
          description: Unix seconds, exclusive.
      responses:
        '200':
          description: >-
            The filtered exchanges as JSONL (application/jsonl), one
            {"messages": [...]} line per exchange: the request messages with the
            assistant reply appended. Capped at 10,000 rows.
          headers:
            X-Omnia-Export-Count:
              description: Lines returned.
              schema:
                type: integer
            X-Omnia-Export-Capped:
              description: >-
                "true" when the 10,000-row cap was hit. Narrow the filter (e.g.
                a time range) to get the rest.
              schema:
                type: string
          content:
            application/jsonl:
              schema:
                type: string
        '401':
          $ref: '#/components/responses/Unauthorized'
        '409':
          description: >-
            Request logging is disabled for this workspace, so nothing is
            captured. Enable it in workspace settings.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
components:
  responses:
    Unauthorized:
      description: Missing, malformed, or revoked API key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
          example:
            error:
              message: Invalid API key
              type: invalid_request_error
              code: invalid_api_key
  schemas:
    Error:
      type: object
      properties:
        error:
          type: object
          properties:
            message:
              type: string
            type:
              type: string
              description: >-
                invalid_request_error, insufficient_quota, rate_limit_error, or
                api_error.
            code:
              type: string
              description: >-
                Machine-stable cause, e.g. invalid_api_key, not_found,
                insufficient_permissions, precondition_failed.
          required:
            - message
            - type
            - code
      description: >-
        Every refusal — gateway and management API alike — uses this one
        envelope.
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: >-
        Your workspace API key, e.g. `sk_sovereign_...`, sent as `Authorization:
        Bearer <key>`.

````