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

# Generate new proof

> Submit a program for proving with specific input data.

    The input data must be a JSON object with an 'input' key containing an array of hex strings.
    Each hex string represents either:
    - Hex string of bytes (prefixed with 0x01)
    - Hex string of native field elements as u32 little endian (prefixed with 0x02)

    Available proof types:
    - `stark`: STARK proof (default)
    - `evm`: EVM-compatible proof

    ## Example Usage

    ```bash
    curl -X POST "https://api.axiom.xyz/v1/proofs?program_id=your-program-uuid&proof_type=stark" \
      -H "Axiom-API-Key: your-api-key" \
      -H "Content-Type: application/json" \
      -d '{
        "input": [
          "0x010A00000000000000",
          "0x02FF00000000000000"
        ]
      }'
    ```



## OpenAPI

````yaml POST /v1/proofs
openapi: 3.1.0
info:
  title: Axiom Proving API
  description: |-
    ## Axiom Cloud Proving API

        The Axiom Proving API allows you to compile, execute, and prove OpenVM programs on Axiom's cloud infrastructure.

        All endpoints require an API key passed in the `Axiom-API-Key` header.
        
  version: 1.0.0
servers:
  - url: https://api.axiom.xyz
    description: Production API
  - url: https://api.staging.app.axiom.xyz
    description: Staging API
security: []
paths:
  /v1/proofs:
    post:
      tags:
        - proofs
      summary: Submit Proof Request
      description: |-
        Submit a program for proving with specific input data.

            The input data must be a JSON object with an 'input' key containing an array of hex strings.
            Each hex string represents either:
            - Hex string of bytes (prefixed with 0x01)
            - Hex string of native field elements as u32 little endian (prefixed with 0x02)

            Available proof types:
            - `stark`: STARK proof (default)
            - `evm`: EVM-compatible proof

            ## Example Usage

            ```bash
            curl -X POST "https://api.axiom.xyz/v1/proofs?program_id=your-program-uuid&proof_type=stark" \
              -H "Axiom-API-Key: your-api-key" \
              -H "Content-Type: application/json" \
              -d '{
                "input": [
                  "0x010A00000000000000",
                  "0x02FF00000000000000"
                ]
              }'
            ```
      operationId: submit_proof_v1_proofs_post
      parameters:
        - name: program_id
          in: query
          required: true
          schema:
            type: string
            title: Program Id
        - name: proof_type
          in: query
          required: false
          schema:
            type: string
            description: 'The type of proof to generate. must be one of: evm, stark'
            default: stark
            title: Proof Type
          description: 'The type of proof to generate. must be one of: evm, stark'
      requestBody:
        required: true
        content:
          application/json:
            schema:
              type: object
              additionalProperties: true
              description: >-
                The input data must be a json with key `input`, and the value is
                an array of hex strings
                        Each hex string is either:
                        - Hex string of bytes, which is prefixed with 0x01
                        - Hex string of native field elements (represented as u32, little endian), prefixed with 0x02
                        
              examples:
                - input:
                    - '0x010A00000000000000'
              title: Input Data
      responses:
        '200':
          description: Successful Response
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/PostResponse'
        '201':
          description: Proof job submitted successfully
        '400':
          description: Invalid input data or proof type
        '404':
          description: Program not found
        '422':
          description: Validation Error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HTTPValidationError'
      security:
        - APIKeyHeader: []
components:
  schemas:
    PostResponse:
      properties:
        id:
          type: string
          title: Id
      type: object
      required:
        - id
      title: PostResponse
      description: Generic response for POST operations.
    HTTPValidationError:
      properties:
        detail:
          items:
            $ref: '#/components/schemas/ValidationError'
          type: array
          title: Detail
      type: object
      title: HTTPValidationError
    ValidationError:
      properties:
        loc:
          items:
            anyOf:
              - type: string
              - type: integer
          type: array
          title: Location
        msg:
          type: string
          title: Message
        type:
          type: string
          title: Error Type
      type: object
      required:
        - loc
        - msg
        - type
      title: ValidationError
  securitySchemes:
    APIKeyHeader:
      type: apiKey
      in: header
      name: Axiom-API-Key

````