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

> ## Agent Instructions
> The Venice API is OpenAI-compatible: use any OpenAI SDK with the base URL `https://api.venice.ai/api/v1` and a Venice API key, or pay per request from a USDC wallet through x402 with no account.
> Read model IDs from `GET /models` or `GET /models/traits` at runtime instead of hardcoding them from memory or from these pages. Models are added and retired often.
> Every model's price is in https://docs.venice.ai/pricing.md. Quote video and audio jobs with `POST /video/quote` or `POST /audio/quote` before you queue them.
> Search these docs from an MCP client at https://docs.venice.ai/mcp. The full agent guide is https://docs.venice.ai/agents.md.

# إنشاء القرارات

> **Beta**: This endpoint is currently in beta and may be unstable. Request/response schemas and behavior may change without notice.

Evaluate a `state` against a map of typed `questions` and get back structured `answers`, one per question. Question types: `noul` (yes/no probability), `choice` (pick one option with full probability distribution), and `score` (probability-weighted position on an ordered rubric). Every question is evaluated in parallel against the same state. This endpoint returns typed judgments, not generated text. It is also available at `/api/v1/systemone` for drop-in compatibility with TypeSafe SDKs (set `TYPESAFE_BASE_URL=https://api.venice.ai/api`).

**Authentication:** This endpoint accepts either a Bearer API key or a `SIGN-IN-WITH-X` header for x402 wallet-based authentication. The legacy `X-Sign-In-With-X` header is also accepted during migration. When using x402, a `402 Payment Required` response indicates insufficient balance and includes top-up instructions.



## OpenAPI

````yaml POST /decisions
openapi: 3.0.0
info:
  description: The Venice.ai API.
  termsOfService: https://venice.ai/legal/tos
  title: Venice.ai API
  version: '20261111.072015'
  x-guidance: >-
    Venice.ai is an OpenAI-compatible inference API supporting text, image,
    audio, and video generation.


    **Authentication options:**

    - API Key: Use Bearer token in Authorization header

    - x402 Wallet: Use a prepaid x402 credit balance via EVM or Solana wallet
    (no account required)


    **For x402 wallet access:**

    1. POST /x402/top-up without headers to get payment requirements

    2. Choose one of the returned Base or Solana payment options and sign a USDC
    payment using the x402 SDK

    3. POST /x402/top-up with PAYMENT-SIGNATURE header to add credits

    4. Call any inference endpoint with SIGN-IN-WITH-X header


    **Pricing:** Prepaid credits consumed per request. Check /models for
    available models and their capabilities.
servers:
  - url: https://api.venice.ai/api/v1
security:
  - BearerAuth: []
tags:
  - description: >-
      Generate speech/audio, transcribe audio, and manage asynchronous audio
      generation jobs.
    name: Audio
  - description: >-
      Given a list of messages comprising a conversation, the model will return
      a response. Supports multimodal inputs including text, images, audio
      (input_audio), and video (video_url) for compatible models.
    name: Chat
  - description: >-
      Create vector embeddings from text. `input` must be a string or an array
      of strings. Token arrays are not supported. LangChain OpenAIEmbeddings
      must set `check_embedding_ctx_length=False` to send text instead of
      tiktoken IDs.
    name: Embeddings
  - description: >-
      Evaluate a state against typed questions and get structured answers
      (yes/no probabilities, option picks with distributions, rubric scores).
      **Beta**: This API is currently in beta and may be unstable.
      Request/response schemas and behavior may change without notice.
    name: Decisions
  - description: List and describe the various models available in the API.
    name: Models
  - description: Generate and manipulate images using AI models.
    name: Image
  - description: Generate videos using AI models.
    name: Video
  - description: List and retrieve character information for use in completions.
    name: Characters
  - description: >-
      Billing and usage analytics. **Beta**: This API is currently in beta and
      may be unstable. Endpoints, request/response schemas, and behavior may
      change without notice.
    name: Billing
  - description: Proxy JSON-RPC requests to blockchain nodes. Billed per credit.
    name: Crypto RPC
  - description: >-
      Wallet-based API access using the x402 protocol. No API key required —
      authenticate with an EVM or Solana wallet.


      **How it works:**

      1. **Authenticate** — Send a `SIGN-IN-WITH-X` header (base64-encoded
      signed SIWX payload) with any request. EVM wallets sign an EIP-4361 SIWE
      message; Solana wallets sign the Solana SIWX message with Ed25519. See the
      `siwx` security scheme for the exact format.

      2. **Top up** — `POST /x402/top-up` without a payment header returns an
      `accepts` array with Base and Solana USDC payment options. Choose one
      entry, sign it using the x402 SDK (`npm install x402`), and re-submit with
      the `PAYMENT-SIGNATURE` header (the legacy `X-402-Payment` and `X-PAYMENT`
      names are also accepted).

      3. **Use any endpoint** — All inference endpoints (chat, image, audio,
      video, embeddings) accept `siwx` as an alternative to `BearerAuth`.
      Charges are deducted from your x402 credit balance.

      4. **Monitor balance** — `GET /x402/balance/{walletAddress}` returns your
      current balance. The `X-Balance-Remaining` response header on inference
      calls also reports it.


      **Quick start (5 lines):**

      ```

      import { VeniceClient } from 'venice-x402-client'

      const venice = new VeniceClient(process.env.WALLET_KEY)

      await venice.topUp(10) // $10 USDC on a supported x402 rail

      const res = await venice.chat({ model: 'zai-org-glm-5-1', messages: [{
      role: 'user', content: 'Hello!' }] })

      ```


      **Payment:** USDC on Base (chain ID 8453) or Solana mainnet. Minimum
      top-up: $5.
    name: x402
externalDocs:
  description: Venice.ai API documentation
  url: https://docs.venice.ai
paths:
  /decisions:
    post:
      tags:
        - Decisions
      summary: /api/v1/decisions
      description: >-
        **Beta**: This endpoint is currently in beta and may be unstable.
        Request/response schemas and behavior may change without notice.


        Evaluate a `state` against a map of typed `questions` and get back
        structured `answers`, one per question. Question types: `noul` (yes/no
        probability), `choice` (pick one option with full probability
        distribution), and `score` (probability-weighted position on an ordered
        rubric). Every question is evaluated in parallel against the same state.
        This endpoint returns typed judgments, not generated text. It is also
        available at `/api/v1/systemone` for drop-in compatibility with TypeSafe
        SDKs (set `TYPESAFE_BASE_URL=https://api.venice.ai/api`).


        **Authentication:** This endpoint accepts either a Bearer API key or a
        `SIGN-IN-WITH-X` header for x402 wallet-based authentication. The legacy
        `X-Sign-In-With-X` header is also accepted during migration. When using
        x402, a `402 Payment Required` response indicates insufficient balance
        and includes top-up instructions.
      operationId: createDecision
      parameters:
        - description: Supported compression encodings (gzip, br)
          in: header
          name: Accept-Encoding
          required: false
          schema:
            example: gzip, br
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/CreateDecisionRequestSchema'
      responses:
        '200':
          description: OK
          headers:
            X-Balance-Remaining:
              description: >-
                Remaining x402 credit balance in USD after this request (only
                present for x402 auth).
              required: false
              schema:
                type: string
                example: '4.230000'
            Content-Encoding:
              description: The encoding used to compress the response
              schema:
                enum:
                  - gzip
                  - br
                type: string
          content:
            application/json:
              schema:
                type: object
                properties:
                  model:
                    type: string
                    description: The model that performed the evaluation.
                  answers:
                    type: object
                    additionalProperties:
                      anyOf:
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - noul
                            noul:
                              type: number
                              minimum: 0
                              maximum: 1
                              description: >-
                                The yes/no answer on a scale from 0 (no) to 1
                                (yes).
                          required:
                            - type
                            - noul
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - choice
                            choice:
                              type: string
                              description: The highest-probability option.
                            probabilities:
                              type: object
                              additionalProperties:
                                type: number
                                minimum: 0
                                maximum: 1
                              description: >-
                                Every option mapped to its probability (floats
                                that sum to 1).
                            confidence:
                              type: number
                              minimum: 0
                              maximum: 1
                              description: >-
                                How certain the model is, derived from the
                                probability distribution.
                          required:
                            - type
                            - choice
                            - probabilities
                            - confidence
                        - type: object
                          properties:
                            type:
                              type: string
                              enum:
                                - score
                            score:
                              type: number
                              minimum: 0
                              description: >-
                                The probability-weighted answer across the
                                levels; can land between levels.
                            legend:
                              type: object
                              additionalProperties:
                                type: string
                              description: >-
                                Each level number mapped back to its
                                description.
                            probabilities:
                              type: object
                              additionalProperties:
                                type: number
                                minimum: 0
                                maximum: 1
                              description: >-
                                Each level (string key) mapped to its
                                probability (floats that sum to 1).
                            confidence:
                              type: number
                              minimum: 0
                              maximum: 1
                              description: >-
                                How certain the model is, derived from the
                                probability distribution.
                          required:
                            - type
                            - score
                            - legend
                            - probabilities
                            - confidence
                        - type: object
                          properties:
                            type:
                              type: string
                          required:
                            - type
                    description: >-
                      One answer per question, keyed by the same ids used in the
                      request.
                  usage:
                    type: object
                    properties:
                      input_tokens:
                        type: integer
                        minimum: 0
                        description: Tokens consumed by the state and questions.
                      output_tokens:
                        type: integer
                        minimum: 0
                        description: Tokens produced evaluating the questions.
                    required:
                      - input_tokens
                      - output_tokens
                required:
                  - model
                  - answers
                  - usage
                example:
                  model: jev-latest
                  answers:
                    is_urgent:
                      type: noul
                      noul: 0.92
                  usage:
                    input_tokens: 312
                    output_tokens: 48
        '400':
          description: Invalid request parameters
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/DetailedError'
        '401':
          description: |-
            - Authentication failed
            - This model is only available to Pro users
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardError'
        '402':
          description: >-
            Payment or balance required. Response varies by authentication
            state:


            **API Key users:** Standard error response with
            `INSUFFICIENT_BALANCE` code. Top up your Venice balance at
            venice.ai.


            **Unauthenticated x402 discovery:** Structured x402 response with
            `x402Version`, `resource`, `accepts`, and
            `extensions["sign-in-with-x"]`. The `accepts` array advertises Base
            and Solana payment requirements.


            **Authenticated x402 wallet users with insufficient credit:**
            Structured response with `PAYMENT_REQUIRED` code containing:

            - `topUpInstructions`: Step-by-step guide to top up via x402
            protocol

            - `supportedTokens` / `supportedChains`: Accepted payment methods

            - `siwxChallenge`: Fresh Sign-In-With-X challenge metadata


            The `PAYMENT-REQUIRED` header also contains a base64-encoded x402
            protocol object with the payment requirements for programmatic
            discovery.
          headers:
            PAYMENT-REQUIRED:
              description: >-
                Base64-encoded JSON with x402 payment requirements. Present on
                x402 middleware 402 responses. Decode to choose and sign one
                accepted payment requirement programmatically.
              required: false
              schema:
                type: string
          content:
            application/json:
              schema:
                oneOf:
                  - $ref: '#/components/schemas/StandardError'
                  - $ref: '#/components/schemas/X402InferencePaymentRequired'
        '403':
          $ref: '#/components/responses/ApiKeyIpRestrictedError'
        '415':
          description: Invalid request content-type
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardError'
        '429':
          description: Rate limit exceeded
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardError'
        '500':
          description: Inference processing failed
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardError'
        '503':
          description: The model is at capacity. Please try again later.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/StandardError'
      security:
        - BearerAuth: []
        - siwx: []
components:
  schemas:
    CreateDecisionRequestSchema:
      type: object
      properties:
        state:
          anyOf:
            - type: string
              minLength: 1
            - type: object
              additionalProperties:
                nullable: true
            - type: array
              items:
                nullable: true
              minItems: 1
          description: >-
            The content to evaluate: a plain string for text, or structured data
            (object/array) for things like chat logs, records, or application
            state.
          example: Help! My payouts have been failing for 3 days.
        model:
          anyOf:
            - type: string
            - type: string
              enum:
                - jev-latest
                - clef
                - clef-api
          description: >-
            ID of the decision model to use. You can use the List models API
            (type=decision) to see available models, or see our Model overview
            for descriptions of them.
          example: jev-latest
        images:
          type: array
          items:
            anyOf:
              - type: string
                minLength: 1
                maxLength: 13631488
                pattern: ^data:image\/(?:png|jpeg|jpg);base64,[A-Za-z0-9+/]+=*$
                description: A `data:` URI for a PNG or JPEG. Remote URLs are not fetched.
                example: data:image/png;base64,iVBORw0KGgo=
              - type: object
                properties:
                  content_type:
                    type: string
                    enum:
                      - image/png
                      - image/jpeg
                      - image/jpg
                    description: MIME type of the embedded image.
                  base64:
                    type: string
                    minLength: 1
                    maxLength: 13631488
                    pattern: ^[A-Za-z0-9+/]+=*$
                    description: 'Raw base64 image bytes without a data: prefix.'
                required:
                  - content_type
                  - base64
                additionalProperties: false
          minItems: 1
          maxItems: 4
          description: >-
            Up to 4 images the model should look at. Each entry is a `data:` URI
            or `{ content_type, base64 }`. Remote URLs are not fetched.
        questions:
          type: object
          additionalProperties:
            oneOf:
              - type: object
                properties:
                  type:
                    type: string
                    enum:
                      - noul
                  instructions:
                    anyOf:
                      - type: string
                        minLength: 1
                      - type: object
                        additionalProperties:
                          nullable: true
                      - type: array
                        items:
                          nullable: true
                        minItems: 1
                    description: The yes/no question to evaluate against the state.
                    example: Does this message convey urgency?
                  criteria:
                    type: object
                    properties:
                      'true':
                        type: string
                        description: What a yes (value near 1) means.
                      'false':
                        type: string
                        description: What a no (value near 0) means.
                required:
                  - type
                  - instructions
                additionalProperties: false
              - type: object
                properties:
                  type:
                    type: string
                    enum:
                      - choice
                  instructions:
                    anyOf:
                      - type: string
                        minLength: 1
                      - type: object
                        additionalProperties:
                          nullable: true
                      - type: array
                        items:
                          nullable: true
                        minItems: 1
                    description: What the model should decide.
                    example: Which team should handle this?
                  criteria:
                    type: object
                    additionalProperties:
                      type: string
                      nullable: true
                    description: >-
                      Map of option name to rubric description; use null when an
                      option needs no extra detail.
                    example:
                      billing: Payments, invoicing, refunds
                      technical: Bugs, outages, integrations
                required:
                  - type
                  - instructions
                  - criteria
                additionalProperties: false
              - type: object
                properties:
                  type:
                    type: string
                    enum:
                      - score
                  instructions:
                    anyOf:
                      - type: string
                        minLength: 1
                      - type: object
                        additionalProperties:
                          nullable: true
                      - type: array
                        items:
                          nullable: true
                        minItems: 1
                    description: What the model should rate.
                    example: How frustrated is the customer?
                  criteria:
                    type: array
                    items:
                      type: string
                    minItems: 2
                    description: >-
                      Ordered array of level descriptions, lowest to highest. At
                      least two levels are required.
                    example:
                      - Calm
                      - Frustrated
                      - Very angry
                required:
                  - type
                  - instructions
                  - criteria
                additionalProperties: false
          description: >-
            Map of typed questions, keyed by an id you choose. At least one
            question is required. Answers come back under the same ids. Every
            question is evaluated in parallel and in isolation against the same
            state. Question ids are not sent to the model.
          example:
            is_urgent:
              type: noul
              instructions: Does this message convey urgency?
          minProperties: 1
      required:
        - state
        - model
        - questions
      additionalProperties: false
      description: >-
        Evaluate a state against a map of typed questions and get back
        structured answers, one per question.
    DetailedError:
      type: object
      properties:
        details:
          type: object
          properties: {}
          description: Details about the incorrect input
          example:
            _errors: []
            field:
              _errors:
                - Field is required
        error:
          type: string
          description: A description of the error
      required:
        - error
    StandardError:
      type: object
      properties:
        error:
          type: string
          description: A description of the error
      required:
        - error
    X402InferencePaymentRequired:
      anyOf:
        - type: object
          properties:
            x402Version:
              type: number
              description: x402 protocol version.
              example: 2
            error:
              type: string
              description: Human-readable payment requirement message.
              example: Payment required
            resource:
              type: object
              properties:
                url:
                  type: string
                  description: Protected resource URL.
                  example: https://api.venice.ai/api/v1/chat/completions
                description:
                  type: string
                  description: Human-readable resource description.
                  example: Venice API
                mimeType:
                  type: string
                  description: Resource MIME type.
                  example: application/json
              required:
                - url
                - description
                - mimeType
              additionalProperties: false
            accepts:
              type: array
              items:
                type: object
                properties:
                  scheme:
                    type: string
                    enum:
                      - exact
                    description: x402 payment scheme.
                    example: exact
                  network:
                    type: string
                    description: >-
                      Payment network for this requirement in CAIP-2 form (e.g.
                      `eip155:8453` for Base,
                      `solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` for Solana
                      mainnet).
                    example: solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp
                  asset:
                    type: string
                    description: USDC token address or mint for the selected network.
                    example: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v
                  amount:
                    type: string
                    description: >-
                      Required payment amount in base units (USDC has 6
                      decimals).
                    example: '10000000'
                  payTo:
                    type: string
                    description: Receiver wallet address for the selected network.
                    example: 8qUL23aSj7mDWdoLMXGHFvnVCT9wd7jXcysiekroADEL
                  maxTimeoutSeconds:
                    type: number
                    description: Maximum time allowed for payment settlement.
                    example: 300
                  extra:
                    type: object
                    properties: {}
                    description: >-
                      Network-specific x402 metadata. Solana requirements
                      include a feePayer.
                    example:
                      name: USD Coin
                      version: '2'
                      feePayer: BFK9TLC3edb13K6v4YyH3DwPb5DSUpkWvb7XnqCL9b4F
                required:
                  - scheme
                  - network
                  - asset
                  - amount
                  - payTo
                  - maxTimeoutSeconds
                  - extra
                additionalProperties: false
              description: >-
                Protocol payment requirements. Clients should choose one entry,
                such as Base or Solana, and sign exactly that requirement.
            extensions:
              type: object
              properties: {}
              description: >-
                Protocol extensions. Inference 402 responses include
                `sign-in-with-x` with a SIWX challenge for wallet-credit
                authentication.
            authOptions:
              type: object
              properties:
                apiKey:
                  type: object
                  properties:
                    header:
                      type: string
                      description: API key authentication header format.
                      example: 'Authorization: Bearer YOUR_API_KEY'
                    getKey:
                      type: string
                      description: Where to create or manage API keys.
                      example: https://venice.ai/settings/api
                    docs:
                      type: string
                      description: API key documentation URL.
                      example: https://docs.venice.ai/api-reference
                  required:
                    - header
                    - getKey
                    - docs
                  additionalProperties: false
                x402Wallet:
                  type: object
                  properties:
                    header:
                      type: string
                      description: Header used for Sign-In-With-X wallet authentication.
                      example: SIGN-IN-WITH-X
                    legacyHeader:
                      type: string
                      description: Legacy Sign-In-With-X header accepted during migration.
                      example: X-Sign-In-With-X
                    topUp:
                      type: string
                      description: >-
                        Endpoint used to discover and submit x402 top-up
                        payments.
                      example: POST /api/v1/x402/top-up
                    docs:
                      type: string
                      description: x402 top-up API documentation URL.
                      example: >-
                        https://docs.venice.ai/api-reference/endpoint/x402/top-up
                  required:
                    - header
                    - legacyHeader
                    - topUp
                    - docs
                  additionalProperties: false
              required:
                - apiKey
                - x402Wallet
              additionalProperties: false
          required:
            - x402Version
            - resource
            - accepts
            - authOptions
          additionalProperties: false
          description: >-
            Returned when an inference request has no API key or wallet
            authentication. The JSON body includes x402 discovery requirements
            and authentication options.
        - type: object
          properties:
            error:
              type: string
              enum:
                - Payment required
              description: Error message indicating payment is required.
            code:
              type: string
              enum:
                - PAYMENT_REQUIRED
              description: Machine-readable error code.
            reason:
              type: string
              enum:
                - insufficient_balance
              description: Reason the x402-authenticated request could not proceed.
            message:
              type: string
              description: Human-readable context about the payment requirement.
              example: Insufficient x402 balance
            currentBalanceUsd:
              type: number
              description: Current x402 credit balance for the wallet.
              example: 0.01
            minimumBalanceUsd:
              type: number
              description: Minimum x402 credit balance required before the request can run.
              example: 0.1
            description:
              type: string
              description: Protected resource description.
              example: Venice API
            suggestedTopUpUsd:
              type: number
              description: Suggested amount to top up in USD.
              example: 10
            minimumTopUpUsd:
              type: number
              description: Minimum allowed top-up amount in USD.
              example: 5
            supportedTokens:
              type: array
              items:
                type: string
              description: List of supported token symbols for payment.
              example:
                - USDC
            supportedChains:
              type: array
              items:
                type: string
              description: List of supported top-up rails.
              example:
                - base
                - solana
            topUpInstructions:
              type: object
              properties:
                step1:
                  type: string
                  description: 'First step: get payment requirements.'
                  example: >-
                    POST /api/v1/x402/top-up with no payment header to get
                    payment requirements
                step2:
                  type: string
                  description: 'Second step: sign the payment.'
                  example: >-
                    Choose a payment option from accepts and sign a USDC
                    transfer authorization using the x402 SDK
                    (createPaymentHeader)
                step3:
                  type: string
                  description: 'Third step: submit the payment.'
                  example: >-
                    POST /api/v1/x402/top-up with the signed PAYMENT-SIGNATURE
                    header
                receiverWallet:
                  type: string
                  description: >-
                    Legacy Base receiver wallet address. Prefer the selected
                    accepts entry from /x402/top-up for network-specific payTo
                    values.
                  example: <RECEIVER_WALLET_ADDRESS>
                tokenAddress:
                  type: string
                  description: >-
                    Legacy Base USDC token address. Prefer the selected accepts
                    entry from /x402/top-up for network-specific assets.
                  example: <USDC_TOKEN_ADDRESS>
                tokenDecimals:
                  type: number
                  description: Token decimal places.
                  example: 6
                network:
                  type: string
                  description: >-
                    Legacy Base target network. Prefer the selected accepts
                    entry from /x402/top-up for network-specific values.
                  example: eip155:8453
                minimumAmountUsd:
                  type: number
                  description: Minimum top-up amount in USD.
                  example: 5
              required:
                - step1
                - step2
                - step3
                - receiverWallet
                - tokenAddress
                - tokenDecimals
                - network
                - minimumAmountUsd
              additionalProperties: false
            siwxChallenge:
              type: object
              properties:
                info:
                  type: object
                  properties:
                    domain:
                      type: string
                      description: Domain for the SIWX challenge.
                      example: api.venice.ai
                    uri:
                      type: string
                      description: Resource URI for the challenge.
                      example: https://api.venice.ai/api/v1/chat/completions
                    version:
                      type: string
                      description: SIWX version.
                      example: '1'
                    nonce:
                      type: string
                      description: >-
                        Server-generated nonce for replay protection: 32 hex
                        characters.
                      example: a1b2c3d4e5f67890a1b2c3d4e5f67890
                    issuedAt:
                      type: string
                      description: ISO timestamp when the challenge was issued.
                      example: '2026-04-09T12:00:00.000Z'
                    expirationTime:
                      type: string
                      description: ISO timestamp when the challenge expires.
                      example: '2026-04-09T12:05:00.000Z'
                    statement:
                      type: string
                      description: Human-readable statement for the signature.
                      example: Sign in to Venice AI
                  required:
                    - domain
                    - uri
                    - version
                    - nonce
                    - issuedAt
                    - expirationTime
                    - statement
                  additionalProperties: false
                supportedChains:
                  type: array
                  items:
                    type: object
                    properties:
                      chainId:
                        type: string
                        description: Supported chain identity.
                        example: solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp
                      type:
                        type: string
                        enum:
                          - eip191
                          - ed25519
                        description: >-
                          Signature algorithm: `eip191` for EVM wallets (EOAs
                          and smart contract wallets), `ed25519` for Solana.
                        example: ed25519
                    required:
                      - chainId
                      - type
                    additionalProperties: false
                  description: Supported SIWX chains and signature types.
                schema:
                  type: object
                  properties: {}
                  description: >-
                    JSON Schema of the proof the client sends in the
                    `SIGN-IN-WITH-X` header.
              required:
                - info
                - supportedChains
                - schema
              additionalProperties: false
          required:
            - error
            - code
            - reason
            - suggestedTopUpUsd
            - minimumTopUpUsd
            - supportedTokens
            - supportedChains
            - topUpInstructions
            - siwxChallenge
          additionalProperties: false
    ApiKeyIpRestrictedError:
      type: object
      properties:
        error:
          type: string
          enum:
            - >-
              This API key is restricted to configured IP addresses, and this
              request's source IP is not allowed
          description: A description of the error
          example: >-
            This API key is restricted to configured IP addresses, and this
            request's source IP is not allowed
      required:
        - error
  responses:
    ApiKeyIpRestrictedError:
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ApiKeyIpRestrictedError'
      description: >-
        This API key is restricted to configured IP addresses, and this
        request's source IP is not allowed
  securitySchemes:
    BearerAuth:
      bearerFormat: JWT
      scheme: bearer
      type: http
    siwx:
      description: >-
        Wallet-based authentication using the x402 sign-in-with-x extension.
        Supports EVM wallets on Base (EIP-4361 SIWE, including EIP-1271 smart
        contract wallets) and Ed25519 wallets on Solana mainnet.


        **Header format:** Base64-encoded JSON proof with these fields:

        - `domain` — `api.venice.ai`

        - `address` — EVM or Solana wallet address

        - `uri` — URL of the requested resource

        - `version` — `"1"`

        - `chainId` — `"eip155:8453"` for Base or
        `"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp"` for Solana

        - `type` — `"eip191"` for EVM wallets or `"ed25519"` for Solana

        - `nonce` — the `nonce` from the latest 402 challenge
        (`extensions["sign-in-with-x"].info.nonce`), or 32 random hex
        characters. Each nonce works once.

        - `issuedAt` — ISO 8601 time the proof was signed. Proofs older than 5
        minutes are rejected.

        - `expirationTime`, `notBefore`, `statement`, `resources` — optional

        - `signature` — signature over the message built from these fields: an
        EIP-4361 SIWE message for EVM (hex) or the Solana sign-in message
        (base58)


        Venice rebuilds the signed message from these fields, with the bare
        reference on its `Chain ID` line (`8453`,
        `5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp`). Proofs from older clients that send
        the signed `message` itself are still accepted.


        **Example (TypeScript, viem):**

        ```

        import { privateKeyToAccount } from 'viem/accounts'

        import { createSiweMessage } from 'viem/siwe'


        const account = privateKeyToAccount(PRIVATE_KEY)

        const fields = { domain: 'api.venice.ai', address: account.address, uri:
        'https://api.venice.ai/api/v1/chat/completions', version: '1' as const,
        nonce: crypto.randomUUID().replace(/-/g, ''), issuedAt: new
        Date().toISOString(), statement: 'Sign in to Venice AI' }

        const message = createSiweMessage({ ...fields, chainId: 8453, issuedAt:
        new Date(fields.issuedAt) })

        const signature = await account.signMessage({ message })

        const header = btoa(JSON.stringify({ ...fields, chainId: 'eip155:8453',
        type: 'eip191', signature }))

        // Set header: SIGN-IN-WITH-X: <header>

        ```


        **SDK:** `npm install venice-x402-client` provides `VeniceClient` and
        `createAuthFetch` which handle this automatically.


        **Billing:** x402 users pay from a prepaid x402 credit balance. Top up
        via `POST /x402/top-up`. When balance is insufficient, endpoints return
        `402` with structured top-up instructions.
      in: header
      name: SIGN-IN-WITH-X
      type: apiKey

````

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