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

# Gemini Decisions - Complete Parameter Reference

> - Use `gemini-decision-1` to evaluate text, images, audio, video, and PDFs with yes/no probabilities, single-choice answers, and scores
- Returns all answers synchronously; streaming, Batch API, and context caching are not supported
- Only input tokens are billed; output is free. A minimum charge applies per request. See [Model pricing](https://evolink.ai/pricing)
- For conversation or text generation, use the [Gemini Native API](/en/api-manual/language-series/gemini/native-api/native-api-reference)

> [!NOTE]
>
> **BaseURL**: Use `https://direct.evolink.ai` by default; `https://api.evolink.ai` is the fallback endpoint.


## OpenAPI

````yaml en/api-manual/language-series/gemini/decisions/decisions-reference.json POST /v1beta/decisions
openapi: 3.1.0
info:
  title: Gemini Decisions - Complete Parameter Reference
  description: >-
    Use the Gemini Decisions API to have Gemini Decision 1 answer typed
    questions about text, images, audio, video, and PDF documents: yes/no
    probabilities, one option from a fixed list, or a rating on ordered levels.
  license:
    name: MIT
  version: 1.0.0
servers:
  - url: https://direct.evolink.ai
    description: Production (recommended)
  - url: https://api.evolink.ai
    description: Fallback endpoint
security:
  - bearerAuth: []
tags:
  - name: Decisions
    description: 'Structured decisions: classification, routing, and scoring'
paths:
  /v1beta/decisions:
    post:
      tags:
        - Decisions
      summary: Gemini Decision 1 (structured decisions)
      description: >-
        - Use `gemini-decision-1` to evaluate text, images, audio, video, and
        PDFs with yes/no probabilities, single-choice answers, and scores

        - Returns all answers synchronously; streaming, Batch API, and context
        caching are not supported

        - Only input tokens are billed; output is free. A minimum charge applies
        per request. See [Model pricing](https://evolink.ai/pricing)

        - For conversation or text generation, use the [Gemini Native
        API](/en/api-manual/language-series/gemini/native-api/native-api-reference)
      operationId: createDecision
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/DecisionRequest'
            examples:
              noul:
                summary: Yes/no question
                value:
                  model: gemini-decision-1
                  input: >-
                    The blue mug I ordered on Monday arrived cracked on
                    Wednesday.
                  questions:
                    is_damaged:
                      type: noul
                      instructions: Did the item arrive damaged?
              choice:
                summary: Single choice (routing)
                value:
                  model: gemini-decision-1
                  input: I was charged twice for my order.
                  questions:
                    department:
                      type: choice
                      instructions: Which department should handle this request?
                      criteria:
                        billing: Payments, invoices, and refunds.
                        technical: Problems using the product.
                        shipping: Delivery and tracking.
                        other: Anything outside these categories.
              score:
                summary: Scoring on ordered levels
                value:
                  model: gemini-decision-1
                  input: Export fails in Safari but works in Chrome.
                  questions:
                    severity:
                      type: score
                      instructions: How severe is this issue for the user?
                      criteria:
                        - 'Cosmetic: appearance only, no lost functionality.'
                        - >-
                          Workaround available: a task fails, but another way
                          works.
                        - 'Fully blocked: a task fails with no workaround.'
              multiple:
                summary: Ask multiple questions in one request
                value:
                  model: gemini-decision-1
                  input:
                    - type: text
                      text: >
                        {"order": {"id": "8821", "item": "headphones",
                        "price_usd": 240}, "tier": "Gold"}
                    - type: text
                      text: >-
                        {"message": "Audio cuts out on the left earcup. Fix it
                        today or I cancel my membership."}
                  questions:
                    is_defect:
                      type: noul
                      instructions: Does `message` describe a hardware defect?
                    next_action:
                      type: choice
                      instructions: What is the right resolution given `tier` and `order`?
                      criteria:
                        instant_refund: Refund without return. Low value or clear fault.
                        replacement_shipment: Ship a replacement. Customer returns the original.
                        troubleshooting_flow: The issue may be fixable by the customer.
                        human_escalation: ''
                    churn_risk:
                      type: score
                      instructions: >-
                        How likely is the customer to churn if the issue is not
                        resolved now?
                      criteria:
                        - No churn signal
                        - Mild frustration
                        - Mentions alternatives
                        - Threatens to cancel
              image_base64:
                summary: Evaluate an inline image (base64)
                value:
                  model: gemini-decision-1
                  input:
                    - type: text
                      text: Look at the image.
                    - type: image
                      data: >-
                        iVBORw0KGgoAAAANSUhEUgAAACAAAAAgCAIAAAD8GO2jAAAAKklEQVR42mM4ISdHU8QwasGoBaMWjFowasGoBaMWjFowasGoBaMWDBULACXLED1gHZEpAAAAAElFTkSuQmCC
                      mime_type: image/png
                      resolution: low
                  questions:
                    is_red:
                      type: noul
                      instructions: Is the image mostly red?
              image_url:
                summary: Evaluate an image from a URL
                value:
                  model: gemini-decision-1
                  input:
                    - type: text
                      text: Product photo.
                    - type: image
                      uri: https://www.gstatic.com/webp/gallery/1.jpg
                      mime_type: image/jpeg
                      resolution: low
                  questions:
                    outdoor:
                      type: noul
                      instructions: Is this photo taken outdoors?
                    quality:
                      type: score
                      instructions: How sharp is the photo?
                      criteria:
                        - blurry
                        - ok
                        - sharp
              audio_url:
                summary: Evaluate audio from a URL
                value:
                  model: gemini-decision-1
                  input:
                    - type: audio
                      uri: >-
                        https://storage.googleapis.com/generativeai-downloads/data/Apollo-11_Day-01-Highlights-10s.mp3
                      mime_type: audio/mp3
                  questions:
                    mentions_launch:
                      type: noul
                      instructions: >-
                        Is the speaker talking about spaceflight or a rocket
                        launch?
      responses:
        '200':
          description: One answer per question, keyed by the question keys in the request
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DecisionResponse'
              example:
                answers:
                  is_defect:
                    type: noul
                    noul: 0.94
                    confidence: 0.94
                  next_action:
                    type: choice
                    choice: human_escalation
                    probabilities:
                      human_escalation: 0.76
                      replacement_shipment: 0.18
                      troubleshooting_flow: 0.04
                      instant_refund: 0.02
                    confidence: 0.76
                  churn_risk:
                    type: score
                    score: 2.99
                    legend:
                      '0': No churn signal
                      '1': Mild frustration
                      '2': Mentions alternatives
                      '3': Threatens to cancel
                    probabilities:
                      '0': 0
                      '1': 0
                      '2': 0.01
                      '3': 0.99
                    confidence: 0.99
                usage:
                  total_input_tokens: 324
                  input_tokens_by_modality:
                    - modality: text
                      tokens: 324
                  total_output_tokens: 0
                  total_tokens: 324
        '400':
          description: >-
            Invalid request. When the request content is invalid, `code` is
            `invalid_request` and `message` names the field and the rule that
            failed. Common causes: an unsupported question `type`, a `choice` or
            `score` question without `criteria`, fewer than 2 options or levels,
            an invalid question key, empty `input`, an unknown field (such as
            `stream`), a `mime_type` that does not match the content, or a
            `gs://` URI or `files/...` name. Input blocked by safety filters
            returns `safety`, `prohibited_content`, `blocklist`, `image_safety`,
            or `content_blocked`. Using this model on another endpoint returns
            `model_endpoint_mismatch`. HTTP error responses are not billed.
            Safety feedback in an HTTP 200 response is still billed; see
            `usage`.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                invalid_question_type:
                  summary: Unsupported question type
                  value:
                    error:
                      message: >-
                        The value 'bool' is not supported for 'type' at
                        'questions.q'. Supported values: 'choice', 'noul',
                        'score'. (request id: 20261112194236591724000xVRbpAJk)
                      type: ''
                      param: ''
                      code: invalid_request
                safety_blocked:
                  summary: Input blocked by safety filters
                  value:
                    error:
                      message: >-
                        Request blocked due to safety violations (harmful
                        content). Please modify your input and retry. (request
                        id: 20261112194253810462000pRk2HvTe)
                      type: ''
                      param: ''
                      code: safety
                model_endpoint_mismatch:
                  summary: Model sent to the wrong endpoint
                  value:
                    error:
                      allowed_endpoints:
                        - /v1beta/decisions
                      code: model_endpoint_mismatch
                      expected_endpoint: /v1beta/decisions
                      message: >-
                        The model 'gemini-decision-1' cannot be used with
                        /v1/decisions. Allowed endpoints: /v1beta/decisions.
                        (request id: 20261112194245600264000oIU8uBcu)
                      param: null
                      retryable: false
                      type: invalid_request_error
        '401':
          description: 'Unauthorized: API Key is missing or invalid'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              example:
                error:
                  code: unauthorized
                  message: >-
                    API key is required (request id:
                    202611121942512304710006r9sjD0r)
                  param: null
                  type: authentication_error
        '402':
          description: Insufficient balance
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: >-
            Permission denied. `permission_denied`: `input` references a Google
            Files API file, which only the Google project that uploaded it can
            access; send the media as a public or signed HTTPS URL or as inline
            base64 instead. This status is also returned when the API Key has a
            model allowlist that does not include this model
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                permission_denied:
                  summary: Google Files API URI used
                  value:
                    error:
                      message: >-
                        You do not have permission to access the File abc123xyz
                        or it may not exist. (request id:
                        20261112194238873347000q1Tkqeid)
                      type: ''
                      param: ''
                      code: permission_denied
        '404':
          description: >-
            Not found. `not_found`: a media URL in `input` could not be fetched;
            make sure it is a publicly reachable or correctly signed HTTPS URL.
            `model_not_found`: the model is not available for the Decisions API;
            currently only `gemini-decision-1` is supported
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
              examples:
                url_not_found:
                  summary: Media URL could not be fetched
                  value:
                    error:
                      message: >-
                        Cannot fetch content from the provided URL. The URL
                        could not be found. Please double-check the URL for any
                        errors. (request id: 20261112194241224738000Vx0uduIQ)
                      type: ''
                      param: ''
                      code: not_found
                model_not_found:
                  summary: Model not available for Decisions
                  value:
                    error:
                      code: model_not_found
                      message: >-
                        Model 'gemini-3.8-flash' is not available for the
                        Decisions API (POST /v1beta/decisions) with this API
                        key. This error is permanent — do not retry with the
                        same model id. Call GET /v1/models: Decisions models for
                        this endpoint are listed as gemini-decision-*. (request
                        id: 20261112194249376584000tUELY8LN)
                      param: null
                      retryable: false
                      type: invalid_request_error
        '429':
          description: Rate limit exceeded; retry later
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '500':
          description: Internal server error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '503':
          description: Service temporarily unavailable; retry later
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
components:
  schemas:
    DecisionRequest:
      type: object
      additionalProperties: false
      required:
        - model
        - input
        - questions
      properties:
        model:
          type: string
          description: >-
            Model ID. Use `gemini-decision-1`.


            This model is not a chat model and only works on this endpoint. For
            example, sending it to the GPT Decisions endpoint `/v1/decisions`
            returns `400 model_endpoint_mismatch`.
          enum:
            - gemini-decision-1
          example: gemini-decision-1
        input:
          description: >-
            Shared input for all questions: a text string, a single content
            block, or an array of content blocks (text, image, audio, video, or
            PDF document). Input cannot be empty. Adjacent text blocks are
            joined in order with no separator, so add your own spaces or
            newlines. To pass JSON data, serialize it to a string and send it as
            text.
          oneOf:
            - type: string
              minLength: 1
              example: I was charged twice for my order.
            - $ref: '#/components/schemas/InputContent'
            - type: array
              minItems: 1
              items:
                $ref: '#/components/schemas/InputContent'
        questions:
          type: object
          description: >-
            Questions to evaluate, as a map from question key to question: 1 to
            1,000 questions. You choose the keys (1 to 64 characters matching
            `[A-Za-z0-9_-]+`), and each answer is returned under the same key.
            The model never sees the keys, so write the full question in
            `instructions`.


            | Type | Purpose | Main result |

            |---|---|---|

            | `noul` | Check whether a statement holds | `noul`: probability of
            “yes” (0.01 to 0.99) |

            | `choice` | Pick one option from a fixed list | `choice`: the most
            likely option ID |

            | `score` | Rate the input on ordered levels | `score`:
            probability-weighted level score |


            Each question is evaluated independently against the same input and
            cannot see the others; question types can be mixed. If questions
            depend on one another, split them into separate requests. The input
            and all questions share a 262,144-token context window.
          minProperties: 1
          maxProperties: 1000
          propertyNames:
            pattern: ^[A-Za-z0-9_-]{1,64}$
          additionalProperties:
            oneOf:
              - $ref: '#/components/schemas/NoulQuestion'
              - $ref: '#/components/schemas/ChoiceQuestion'
              - $ref: '#/components/schemas/ScoreQuestion'
          example:
            is_damaged:
              type: noul
              instructions: Did the item arrive damaged?
      description: >-
        The request body accepts only `model`, `input`, and `questions`. Any
        other field (such as `stream`) returns `400 invalid_request`.
    DecisionResponse:
      type: object
      properties:
        answers:
          type: object
          description: >-
            One answer per question, keyed by the question keys in the request.
            Each answer’s `type` matches its question. Empty when
            `prompt_feedback.block_reason` is set
          additionalProperties:
            oneOf:
              - $ref: '#/components/schemas/NoulAnswer'
              - $ref: '#/components/schemas/ChoiceAnswer'
              - $ref: '#/components/schemas/ScoreAnswer'
        usage:
          $ref: '#/components/schemas/DecisionUsage'
        prompt_feedback:
          $ref: '#/components/schemas/PromptFeedback'
    ErrorResponse:
      type: object
      properties:
        error:
          type: object
          properties:
            message:
              type: string
              description: >-
                Error description, ending with `(request id: ...)`. Provide this
                ID when troubleshooting
            type:
              type:
                - string
                - 'null'
              description: Error type; may be empty
            param:
              type:
                - string
                - 'null'
              description: Related parameter; may be empty
            code:
              type:
                - string
                - 'null'
              description: >-
                Error code, such as `invalid_request`, `permission_denied`,
                `not_found`, `safety`, `model_not_found`, or
                `model_endpoint_mismatch`
    InputContent:
      description: A content block. `type` determines the other fields
      oneOf:
        - $ref: '#/components/schemas/TextContent'
        - $ref: '#/components/schemas/ImageContent'
        - $ref: '#/components/schemas/AudioContent'
        - $ref: '#/components/schemas/VideoContent'
        - $ref: '#/components/schemas/DocumentContent'
    NoulQuestion:
      type: object
      description: Yes/no question
      required:
        - type
        - instructions
      properties:
        type:
          type: string
          enum:
            - noul
        instructions:
          $ref: '#/components/schemas/QuestionInstructions'
        criteria:
          type: object
          description: >-
            Optional. Defines what “yes” and “no” mean when the question alone
            is ambiguous
          properties:
            true_description:
              type: string
              description: When the answer is “yes”
            false_description:
              type: string
              description: When the answer is “no”
    ChoiceQuestion:
      type: object
      description: Single-choice question
      required:
        - type
        - instructions
        - criteria
      properties:
        type:
          type: string
          enum:
            - choice
        instructions:
          $ref: '#/components/schemas/QuestionInstructions'
        criteria:
          type: object
          description: >-
            Options, as a map from option ID to a description of when it applies
            (use an empty string `""` when the ID is self-explanatory). 2 to 255
            options. Option IDs are 1 to 128 characters (up to 512 UTF-8 bytes);
            internal ASCII spaces are allowed, but leading or trailing spaces
            and control characters are not. Option IDs are sorted alphabetically
            (UTF-8 byte order) before evaluation, and exact ties resolve to the
            alphabetically first ID, so use a non-positional catch-all ID such
            as `other` rather than `none_of_the_above`
          minProperties: 2
          maxProperties: 255
          additionalProperties:
            type: string
          example:
            billing: Payments, invoices, and refunds.
            technical: Problems using the product.
            shipping: Delivery and tracking.
            other: Anything outside these categories.
    ScoreQuestion:
      type: object
      description: Score question
      required:
        - type
        - instructions
        - criteria
      properties:
        type:
          type: string
          enum:
            - score
        instructions:
          $ref: '#/components/schemas/QuestionInstructions'
        criteria:
          type: array
          description: >-
            Level descriptions ordered from lowest to highest: 2 to 255
            non-empty strings (2 to 10 recommended). Level `i` (starting at 0)
            is described by `criteria[i]`. Because `score` averages level
            indices, keep the scale linear and adjacent levels clearly distinct
          minItems: 2
          maxItems: 255
          items:
            type: string
            minLength: 1
          example:
            - 'Cosmetic: appearance only, no lost functionality.'
            - 'Workaround available: a task fails, but another way works.'
            - 'Fully blocked: a task fails with no workaround.'
    NoulAnswer:
      type: object
      properties:
        type:
          type: string
          enum:
            - noul
        noul:
          type: number
          minimum: 0.01
          maximum: 0.99
          description: >-
            Calibrated probability that the answer is “yes”, from 0.01 to 0.99;
            the probability of “no” is `1 - noul`. Set thresholds within this
            range using labeled examples from your own traffic
        confidence:
          type: number
          minimum: 0
          maximum: 1
          description: >-
            Estimated probability that the top answer is right, equal to
            `max(noul, 1 - noul)`
    ChoiceAnswer:
      type: object
      properties:
        type:
          type: string
          enum:
            - choice
        choice:
          type: string
          description: The option ID with the highest probability
        probabilities:
          type: object
          description: >-
            Calibrated probability for each option ID, summing to 1. Probability
            is always spread across your options, even when none fits
          additionalProperties:
            type: number
        confidence:
          type: number
          minimum: 0
          maximum: 1
          description: >-
            Probability of the selected option, from 0 to 1. When it is low,
            consider human review or a separate yes/no scope check
    ScoreAnswer:
      type: object
      properties:
        type:
          type: string
          enum:
            - score
        score:
          type: number
          description: >-
            Probability-weighted average of the level indices (`sum(k ×
            probability_k)`), so it can fall between levels. Divide it by the
            highest level index to normalize it to 0–1
        probabilities:
          type: object
          description: >-
            Calibrated probability for each level index (`"0"`, `"1"`, ...),
            summing to 1. For a discrete level, take the index with the highest
            probability
          additionalProperties:
            type: number
        legend:
          type: object
          description: Description of each level index, taken from `criteria`
          additionalProperties:
            type: string
        confidence:
          type: number
          minimum: 0
          maximum: 1
          description: The highest probability in `probabilities`, from 0 to 1
    DecisionUsage:
      type: object
      description: >-
        Token usage. Only input tokens are billed (`total_input_tokens`): text,
        image, audio, video, and PDF tokens cost the same, and output is always
        0. A minimum charge applies to each request. See [Model
        pricing](https://evolink.ai/pricing) for current prices. Context caching
        is not supported; repeated input is billed separately for each request.
        If an HTTP 200 response contains `prompt_feedback.block_reason`, input
        usage is still billed. If valid usage is not returned, billing uses an
        estimate.
      properties:
        total_input_tokens:
          type: integer
          description: >-
            Billable input tokens for the shared input and all questions. The
            shared input counts once per request regardless of how many
            questions you ask; each question adds only its own instructions and
            criteria
          example: 324
        input_tokens_by_modality:
          type: array
          description: Input tokens by modality
          items:
            type: object
            properties:
              modality:
                type: string
                description: >-
                  Modality: `text`, `image`, or `audio`. Video frames and PDF
                  page images are counted as `image`
              tokens:
                type: integer
                description: Token count for this modality
        total_output_tokens:
          type: integer
          description: Always 0; this model generates no text
          example: 0
        total_tokens:
          type: integer
          description: Total tokens
          example: 324
    PromptFeedback:
      type: object
      description: >-
        Feedback from input content filters. When `block_reason` is set, the
        input was blocked, no questions were evaluated, and `answers` is empty.
        If returned with HTTP 200, the request is still billed; see `usage`.
      properties:
        block_reason:
          type: string
          enum:
            - safety
            - other
            - blocklist
            - prohibited_content
            - image_safety
          description: Why the input was blocked
        block_reason_message:
          type: string
          description: Details about why the input was blocked
    TextContent:
      type: object
      required:
        - type
        - text
      properties:
        type:
          type: string
          enum:
            - text
        text:
          type: string
          description: Text content
    ImageContent:
      type: object
      required:
        - type
        - mime_type
      properties:
        type:
          type: string
          enum:
            - image
        data:
          type: string
          contentEncoding: base64
          description: >-
            Base64-encoded file bytes (inline data is limited to 100 MB per
            request in total). Provide either `data` or `uri`
        uri:
          type: string
          format: uri
          description: >-
            Public or signed HTTPS URL of the file (up to 15 MB). Google Files
            API URIs, `gs://` URIs, `files/...` names, and YouTube URLs are not
            supported. Provide either `data` or `uri`
        mime_type:
          type: string
          enum:
            - image/png
            - image/jpeg
            - image/webp
            - image/heic
            - image/heif
            - image/gif
            - image/bmp
            - image/tiff
          description: >-
            MIME type. It must match the real file format; generic types such as
            `application/octet-stream` are rejected
        resolution:
          type: string
          enum:
            - low
            - medium
            - high
            - ultra_high
          description: >-
            Optional. Media resolution, which controls token usage and visual
            detail
    AudioContent:
      type: object
      required:
        - type
        - mime_type
      properties:
        type:
          type: string
          enum:
            - audio
        data:
          type: string
          contentEncoding: base64
          description: >-
            Base64-encoded file bytes (inline data is limited to 100 MB per
            request in total). Provide either `data` or `uri`
        uri:
          type: string
          format: uri
          description: >-
            Public or signed HTTPS URL of the file (up to 15 MB). Google Files
            API URIs, `gs://` URIs, `files/...` names, and YouTube URLs are not
            supported. Provide either `data` or `uri`
        mime_type:
          type: string
          enum:
            - audio/wav
            - audio/mp3
            - audio/mpeg
            - audio/aiff
            - audio/aac
            - audio/ogg
            - audio/flac
            - audio/m4a
            - audio/opus
            - audio/webm
            - audio/l16
            - audio/alaw
            - audio/mulaw
          description: >-
            MIME type. It must match the real file format; generic types such as
            `application/octet-stream` are rejected
    VideoContent:
      type: object
      required:
        - type
        - mime_type
      properties:
        type:
          type: string
          enum:
            - video
        data:
          type: string
          contentEncoding: base64
          description: >-
            Base64-encoded file bytes (inline data is limited to 100 MB per
            request in total). Provide either `data` or `uri`
        uri:
          type: string
          format: uri
          description: >-
            Public or signed HTTPS URL of the file (up to 15 MB). Google Files
            API URIs, `gs://` URIs, `files/...` names, and YouTube URLs are not
            supported. Provide either `data` or `uri`
        mime_type:
          type: string
          enum:
            - video/mp4
            - video/mpeg
            - video/mov
            - video/avi
            - video/webm
            - video/wmv
            - video/x-flv
            - video/3gpp
          description: >-
            MIME type. It must match the real file format; generic types such as
            `application/octet-stream` are rejected
        resolution:
          type: string
          enum:
            - low
            - medium
            - high
          description: >-
            Optional. Media resolution, which controls token usage and visual
            detail. `ultra_high` applies to images only
    DocumentContent:
      type: object
      required:
        - type
        - mime_type
      properties:
        type:
          type: string
          enum:
            - document
        data:
          type: string
          contentEncoding: base64
          description: >-
            Base64-encoded PDF bytes (up to 50 MB). Provide either `data` or
            `uri`
        uri:
          type: string
          format: uri
          description: >-
            Public or signed HTTPS URL of the file (up to 15 MB). Google Files
            API URIs, `gs://` URIs, `files/...` names, and YouTube URLs are not
            supported. Provide either `data` or `uri`
        mime_type:
          type: string
          enum:
            - application/pdf
          description: >-
            MIME type. It must match the real file format; generic types such as
            `application/octet-stream` are rejected
    QuestionInstructions:
      description: >-
        The question to evaluate against `input`, written in full. Text only: a
        string, a text block, or an array of text blocks
      oneOf:
        - type: string
          minLength: 1
        - $ref: '#/components/schemas/TextContent'
        - type: array
          minItems: 1
          items:
            $ref: '#/components/schemas/TextContent'
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: |-
        Authenticate with your EvoLink API Key as a Bearer token.

        **Get an API Key:**

        Visit the [API Key management page](https://evolink.ai/dashboard/keys).

        **Request header:**
        ```
        Authorization: Bearer YOUR_API_KEY
        ```

````

This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.