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

# Create a Job

> To submit a program to be simulated or executed on our quantum hardware, `POST` it to the `jobs` endpoint.
For `ionq.circuit.v0` multi-circuit payloads, each entry in `input.circuits` inherits the parent `gateset` unless the circuit provides its own override.




## OpenAPI

````yaml https://api.ionq.co/v0.3/api-docs POST /jobs
openapi: 3.0.0
info:
  title: IonQ Cloud Platform API
  version: v0.3
  description: |-
    *Last updated: May 6, 2026*
    IonQ's API for accessing the IonQ Quantum Cloud platform
  contact:
    name: IonQ
    email: support@ionq.co
    url: https://ionq.com/
  x-logo:
    url: https://static.ionq.co/images/ionq-logo-dark.png
    altText: IonQ Logo
    href: '#'
servers:
  - url: https://api.ionq.co/v0.3/
security:
  - API_Key: []
paths:
  /jobs:
    post:
      tags:
        - jobs
        - job-output
      summary: Create a Job
      description: >
        To submit a program to be simulated or executed on our quantum hardware,
        `POST` it to the `jobs` endpoint.

        For `ionq.circuit.v0` multi-circuit payloads, each entry in
        `input.circuits` inherits the parent `gateset` unless the circuit
        provides its own override.
      operationId: createJob
      requestBody:
        $ref: '#/components/requestBodies/CreateJob'
      responses:
        '200':
          $ref: '#/components/responses/CreateJob'
      x-codeSamples:
        - lang: curl
          label: Single-circuit job
          source: |
            curl -X POST "https://api.ionq.co/v0.3/jobs" \
              -H "Authorization: apiKey your-api-key" \
              -H "Content-Type: application/json" \
              -d '{ "input": { "format": "ionq.circuit.v0", "qubits": 1, "circuit": [ {"gate": "h", "target": 0} ] } }'
        - lang: curl
          label: Mixed-gateset multi-circuit job
          source: |
            curl -X POST "https://api.ionq.co/v0.3/jobs" \
              -H "Authorization: apiKey your-api-key" \
              -H "Content-Type: application/json" \
              -d '{
                "target": "simulator",
                "name": "mixed gateset program",
                "input": {
                  "format": "ionq.circuit.v0",
                  "gateset": "native",
                  "qubits": 2,
                  "circuits": [
                    {
                      "name": "qis circuit override",
                      "gateset": "qis",
                      "circuit": [
                        {
                          "gate": "h",
                          "target": 0
                        },
                        {
                          "gate": "cnot",
                          "target": 0,
                          "control": 1
                        }
                      ]
                    },
                    {
                      "name": "native circuit from parent",
                      "circuit": [
                        {
                          "gate": "ms",
                          "targets": [0, 1],
                          "phases": [0, 0.25]
                        },
                        {
                          "gate": "gpi2",
                          "target": 0,
                          "phase": 0.75
                        }
                      ]
                    }
                  ]
                }
              }'
components:
  requestBodies:
    CreateJob:
      content:
        application/json:
          schema:
            type: object
            description: A job to be created
            properties:
              name:
                $ref: '#/components/schemas/name'
              metadata:
                $ref: '#/components/schemas/metadata'
              shots:
                $ref: '#/components/schemas/shots'
              target:
                $ref: '#/components/schemas/target'
              noise:
                $ref: '#/components/schemas/noise'
              input:
                $ref: '#/components/schemas/JobInput'
              error_mitigation:
                $ref: '#/components/schemas/ErrorMitigation'
          examples:
            single_circuit:
              summary: Single-circuit QIS job
              value:
                input:
                  format: ionq.circuit.v0
                  qubits: 1
                  circuit:
                    - gate: h
                      target: 0
            mixed_multi_circuit:
              summary: Mixed-gateset multi-circuit job
              value:
                target: simulator
                name: mixed gateset program
                input:
                  format: ionq.circuit.v0
                  gateset: native
                  qubits: 2
                  circuits:
                    - name: qis circuit override
                      gateset: qis
                      circuit:
                        - gate: h
                          target: 0
                        - gate: cnot
                          target: 0
                          control: 1
                    - name: native circuit from parent
                      circuit:
                        - gate: ms
                          targets:
                            - 0
                            - 1
                          phases:
                            - 0
                            - 0.25
                        - gate: gpi2
                          target: 0
                          phase: 0.75
  responses:
    CreateJob:
      description: Successfully created a Job
      content:
        application/json:
          schema:
            type: object
            description: Response body from a successful job creation.
            required:
              - id
              - status
              - request
            properties:
              id:
                $ref: '#/components/schemas/job-uuid'
              status:
                type: string
                description: Status of a job (always `ready`).
                enum:
                  - ready
  schemas:
    name:
      type: string
      description: A job name.
      example: My Awesome Job
    metadata:
      type: object
      description: User defined metadata.
      example:
        custom_key: a string, maximum 400 chars
      additionalProperties: true
    shots:
      type: number
      description: >-
        How many times to execute your circuit when submitting to a QPU or a
        "non-ideal" noisy simulator.
      default: 100
    target:
      type: string
      description: Target hardware for job to run on.
      default: simulator
      enum:
        - qpu.harmony
        - qpu.aria-1
        - qpu.aria-2
        - qpu.forte-1
        - qpu.forte-enterprise-1
        - simulator
    noise:
      description: >-
        When the target is "simulator", this field specifies optional noise
        parameters for simulation. (If these noise parameters are not provided,
        simulations will run on an ideal quantum computer model, without noise.)
        This field does not apply to `qpu.*` targets. When a noise model is
        applied, the simulator qubit limit is inherited from the modeled QPU's
        qubit limit. (This limit does not apply to the ideal quantum computer
        simulator. Please refer to the current qubit limit of the ideal quantum
        computer simulator.)
      type: object
      properties:
        model:
          type: string
          description: >-
            Selects a noise model to apply to a simulation job. The default,
            `ideal`, provides perfect simulation without noise, while other
            noise models like `harmony` are based on noise data collected from
            our actual quantum computers. Note that these are simplified noise
            models, not intended to exactly reproduce real quantum computations.
          enum:
            - harmony
            - aria-1
            - ideal
        seed:
          type: integer
          description: >-
            This is the seed value for the pseudo-random sampling and noise
            generation when a system noise model is specified. The seed needs to
            be a positive integer between 1 and 2^31. Providing a seed is
            optional and allows for repeatable (i.e. non-random) outcomes. If a
            seed is not specified, one is chosen at random and will be provided
            in the output for the simulation. This field does not apply to
            simulations using the "ideal" noise model. This field also does not
            apply to `qpu.*` targets.
          example: 100
    JobInput:
      type: object
      title: JobInput
      description: Input for creating a job via a Quantum Program
      properties:
        format:
          type: string
          default: ionq.circuit.v0
      oneOf:
        - $ref: '#/components/schemas/CircuitSpecification'
        - $ref: '#/components/schemas/OpenQASMSourceBody'
        - $ref: '#/components/schemas/QASMSourceBody'
        - $ref: '#/components/schemas/QuipperSourceBody'
    ErrorMitigation:
      type: object
      description: >-
        Which error mitigation methods to apply to this circuit. This may affect
        how the job is compiled, and what configuration can be used to fetch
        results.
      properties:
        debias:
          type: boolean
          description: >-
            Set to true to turn on
            [debiasing](https://ionq.com/resources/debiasing-and-sharpening),
            which can improve circuit performance by removing qubit-specific
            noise. _Debiasing is on by default for Aria-class systems._
    job-uuid:
      type: string
      format: uuid
      example: aa54e783-0a9b-4f73-ad2f-63983b6aa4a8
      description: >-
        The UUID of a job. We'll provide the UUID initially in our response to a
        [job creation request](#operation/createJob).
    CircuitSpecification:
      title: ionq.circuit.v0
      type: object
      description: >-
        Quantum circuits for simulation or execution may be submitted as JSON
        using a [simple
        schema](#section/Job-Inputs/ionq.circuit.v0-Specification).
      properties:
        format:
          type: string
          enum:
            - ionq.circuit.v0
        gateset:
          type: string
          default: qis
      oneOf:
        - $ref: '#/components/schemas/QISInputSpecification'
        - $ref: '#/components/schemas/NativeInputSpecification'
    OpenQASMSourceBody:
      title: OpenQASM Circuit
      type: object
      required:
        - format
      description: Request body for creating circuits from OpenQASM.
      properties:
        format:
          type: string
          enum:
            - openqasm
        data:
          type: string
          description: String source for openqasm.
    QASMSourceBody:
      title: QASM Circuit
      type: object
      required:
        - format
      description: Request body for creating circuits from QASM.
      properties:
        format:
          type: string
          enum:
            - qasm
        data:
          type: string
          description: String source for qasm.
    QuipperSourceBody:
      title: Quipper Circuit
      type: object
      required:
        - format
      description: Request body for creating circuits from Quipper.
      properties:
        format:
          type: string
          enum:
            - quipper
        data:
          type: string
          description: String source for quipper.
    QISInputSpecification:
      title: QIS Gateset
      type: object
      oneOf:
        - type: object
          title: QIS Single Circuit
          required:
            - qubits
            - circuit
          properties:
            format:
              type: string
              enum:
                - ionq.circuit.v0
            gateset:
              type: string
              description: The type of gates to allow for this job.
              enum:
                - qis
            circuit:
              $ref: '#/components/schemas/QISCircuitSpecification'
            qubits:
              type: integer
              description: Number of qubits your circuit requires.
              example: 2
        - type: object
          title: QIS Multi-Circuit
          properties:
            format:
              type: string
              enum:
                - ionq.circuit.v0
            gateset:
              type: string
              description: The type of gates to allow for this job.
              enum:
                - qis
            circuits:
              type: array
              description: A list of circuits to execute
              items:
                anyOf:
                  - $ref: '#/components/schemas/QISCircuit'
                  - $ref: '#/components/schemas/NativeCircuit'
    NativeInputSpecification:
      type: object
      title: Native Gateset
      oneOf:
        - type: object
          title: Native Single Circuit
          description: foo
          required:
            - gateset
            - qubits
            - circuit
          properties:
            format:
              type: string
              enum:
                - ionq.circuit.v0
            gateset:
              type: string
              description: The type of gates to allow for this job.
              enum:
                - native
            circuit:
              $ref: '#/components/schemas/NativeCircuitSpecification'
            qubits:
              type: integer
              description: Number of qubits your circuit requires.
              example: 2
        - type: object
          title: Native Multi-Circuit
          required:
            - gateset
          properties:
            format:
              type: string
              enum:
                - ionq.circuit.v0
            gateset:
              type: string
              description: The type of gates to allow for this job.
              enum:
                - native
            circuits:
              type: array
              description: A list of circuits to execute
              items:
                anyOf:
                  - $ref: '#/components/schemas/NativeCircuit'
                  - $ref: '#/components/schemas/QISCircuit'
    QISCircuitSpecification:
      type: array
      description: Array of QIS circuit operations.
      example:
        - gate: h
          target: 0
        - gate: cnot
          control: 0
          target: 1
      items:
        $ref: '#/components/schemas/QISCircuitOperation'
    QISCircuit:
      type: object
      required:
        - circuit
      properties:
        gateset:
          type: string
          description: >-
            Optional gateset override for this individual circuit. If not
            specified, inherits from parent. When set to 'qis', the circuit must
            use QISCircuitSpecification.
          enum:
            - qis
        name:
          type: string
          description: Optional name for this individual circuit.
        qubits:
          type: integer
          description: Number of qubits your circuit requires.
        registers:
          type: array
          items:
            type: integer
          description: >
            Registers to use in your circuit. Each register is a list of qubit
            indices (starting from zero).
        circuit:
          $ref: '#/components/schemas/QISCircuitSpecification'
    NativeCircuit:
      type: object
      required:
        - circuit
      properties:
        gateset:
          type: string
          description: >-
            Optional gateset override for this individual circuit. If not
            specified, inherits from parent. When set to 'native', the circuit
            must use NativeCircuitSpecification.
          enum:
            - native
        name:
          type: string
          description: Optional name for this individual circuit.
        qubits:
          type: integer
          description: Number of qubits your circuit requires.
        registers:
          type: array
          items:
            type: integer
          description: >
            Registers to use in your circuit. Each register is a list of qubit
            indices (starting from zero).
        circuit:
          $ref: '#/components/schemas/NativeCircuitSpecification'
    NativeCircuitSpecification:
      title: Native Circuit
      type: array
      description: Array of native circuit operations.
      example:
        - gate: gpi2
          phase: 0.1
          target: 1
        - gate: ms
          phases:
            - 0.1
            - 0.2
          targets:
            - 1
            - 2
        - gate: zz
          angle: 0.2
          targets:
            - 1
            - 2
      items:
        $ref: '#/components/schemas/NativeCircuitOperation'
    QISCircuitOperation:
      type: object
      properties:
        gate:
          type: string
          description: Name of gate to apply (see Supported Gates list)
        target:
          type: number
          description: >
            Qubit index (starting from zero) to apply gate to.

            **Note**: If a gate uses multiple target qubits (e.g. CNOT or SWAP),
            use the `targets` array instead.
        targets:
          type: array
          description: >-
            Use in place of `target`, if multiple gate uses multiple targets
            qubits.
          items:
            type: number
        control:
          type: number
          description: >
            Qubit index (starting from zero) to use as a gate control. We
            support up to 7 controls per gate.

            **Note**: If a gate uses multiple control qubits (e.g. `CCNOT`), use
            the `controls` array instead.
        controls:
          type: array
          description: Use in place of `control`, if the gate uses multiple control qubits.
          items:
            type: number
        rotation:
          type: number
          description: Rotation angle in radians, for gates that take it, like RX
    NativeCircuitOperation:
      type: object
      properties:
        gate:
          type: string
          description: >-
            Name of gate to apply (see Native Gates list). This controls which
            set of fields below can be used (phase vs phases, target vs
            targets).
        target:
          type: number
          description: Qubit index (starting from zero) to apply gate to.
        phase:
          type: number
          description: Phase of gate (measured in Turns; i.e., units of 2π)
        phases:
          type: array
          description: >-
            Phases of gate (measured in Turns; i.e., units of 2π). Used for
            gates that target more than one ion.
          items:
            type: number
        angle:
          type: number
          description: >-
            Angle of gate (measured in Turns; i.e., units of 2π), from 0
            (identity) to 0.25 (fully entangled). Optional, used for `ms` gates
            only.
        targets:
          type: array
          description: Qubit index(es) (starting from zero) to apply gate to.
          items:
            type: number
  securitySchemes:
    API_Key:
      type: apiKey
      in: header
      name: Authorization
      description: >
        API keys are associated with a user and can be created on the

        [IonQ Quantum Cloud](https://cloud.ionq.com) application. To
        authenticate, prefix your API Key with `apiKey ` and place it in the
        `Authorization` request header. Ex: `Authorization: apiKey your-api-key`

````