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

# List capabilities

> GET /v1/tools

The capability catalogue: the deterministic media, document, archive, web and code operations that workflow steps — and [`POST /v1/capabilities/{id}/run`](/api-reference/capabilities/run) — can invoke.

These are **not** inference models. [`GET /v1/models`](/api-reference/models) lists those. A capability does a fixed job (resize this, extract that) at a fixed price; a model generates.


## OpenAPI

````yaml openapi.json GET /v1/tools
openapi: 3.0.0
info:
  title: Infery Gateway
  description: >-
    Infery Inference Gateway — OpenAI-compatible API for LLMs, embeddings,
    images, audio, and video
  version: '1.0'
  contact: {}
servers:
  - url: https://api.infery.ai
    description: Production
  - url: http://localhost:3001
    description: Local
security: []
tags: []
paths:
  /v1/tools:
    get:
      tags:
        - Models
      summary: List available workflow capabilities
      description: >-
        The capability catalogue: the deterministic media, document, archive,
        web and code operations that workflow steps and `POST
        /v1/capabilities/{id}/run` can invoke. These are NOT inference models —
        `GET /v1/models` lists those, and excludes these `kind=tool` rows unless
        you pass `include_tools=true`.


        The list comes from a taxonomy compiled into the gateway, so it is
        identical for every workspace and changes only with a gateway deploy —
        cache it rather than fetching it per request. Calling this endpoint is
        not billed and reserves no credits; each entry's `pricing` is what
        running that capability costs.


        Every entry carries the full JSON Schema for its `params` and `input`.
        That is the authoritative description of what a step accepts: read
        constraints (`maxItems`, `enum`, `required`) off these documents rather
        than hard-coding them, since a client compiled against a constant can
        disagree with the gateway it is talking to.
      operationId: listTools
      parameters: []
      responses:
        '200':
          description: >-
            The full capability catalogue. Entries are ordered by category
            (video, audio, image, document, archive, web, code).
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ToolListResponseDto'
        '401':
          description: Unauthorized — invalid or missing API key
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponseDto'
      security:
        - ApiKey: []
components:
  schemas:
    ToolListResponseDto:
      type: object
      properties:
        object:
          type: string
          description: Always `list`.
          enum:
            - list
          example: list
        data:
          description: >-
            Every capability in the taxonomy, grouped by category in the order
            video, audio, image, document, archive, web, code.
          type: array
          items:
            $ref: '#/components/schemas/ToolDto'
      required:
        - object
        - data
    ErrorResponseDto:
      type: object
      properties:
        error:
          description: >-
            The error envelope. Every non-2xx response from this API has this
            shape, so a client can parse failures without branching on the
            endpoint.
          allOf:
            - $ref: '#/components/schemas/ErrorDetailDto'
      required:
        - error
    ToolDto:
      type: object
      properties:
        id:
          type: string
          description: >-
            Capability identifier, `<category>.<operation>`. This is the value
            to send as `type` on a workflow step and as the `:id` path parameter
            of `POST /v1/capabilities/{id}/run`.
          example: image.resize
        object:
          type: string
          description: Always `capability`.
          enum:
            - capability
          example: capability
        category:
          type: string
          description: Category this capability belongs to.
          enum:
            - video
            - audio
            - image
            - document
            - archive
            - web
            - code
          example: image
        display_name:
          type: string
          description: Short human-readable name.
          example: Resize image
        description:
          type: string
          description: One-line summary of what the capability does.
          example: Resize image to target dimensions.
        long_description:
          type: string
          description: >-
            Long-form Markdown documentation for this capability. Present only
            for the capabilities that ship a documentation file.
        input_modality:
          description: >-
            The modality (or modalities) this capability consumes. A single
            string for most capabilities; an array when it takes more than one
            kind of input.
          oneOf:
            - type: string
              enum:
                - video
                - audio
                - image
                - document
                - text
                - archive
                - any
            - type: array
              items:
                type: string
                enum:
                  - video
                  - audio
                  - image
                  - document
                  - text
                  - archive
                  - any
          example: image
        output_modality:
          type: string
          description: The modality this capability produces.
          enum:
            - video
            - audio
            - image
            - document
            - text
            - archive
            - any
          example: image
        composite:
          type: boolean
          description: >-
            Present, and always `true`, for the multi-operation capabilities
            (`image.pipeline`, `audio.pipeline`, `video.pipeline`) whose
            `params` chain a list of operations in one call. Absent for
            single-operation capabilities.
          example: true
        params_schema:
          type: object
          additionalProperties: true
          description: >-
            JSON Schema (draft-07) for this capability's `params` object,
            generated from its Zod declaration. Two caveats a client must know:
            cross-field rules declared as Zod refinements are DROPPED by the
            conversion and do not appear here (the "one of width/height
            required" style of constraint is enforced at run time regardless),
            and the document may carry `x-infery-unit` (what a numeric parameter
            is measured in), `x-infery-enum-labels` (a display name per enum
            value) and `x-infery-value-sources` (keys that are alternative
            spellings of one value) — vendor extensions every JSON Schema
            validator ignores by specification.
        input_schema:
          type: object
          additionalProperties: true
          description: >-
            JSON Schema (draft-07) for this capability's `input` object,
            generated from its Zod declaration. The same two caveats as
            `params_schema` apply.
        sample_input:
          type: object
          additionalProperties: true
          description: >-
            An `input` object valid against `input_schema`, for the capabilities
            that declare one.
          example:
            image_url: https://example.com/photo.png
        examples:
          description: Worked `params` examples, for the capabilities that declare any.
          type: array
          items:
            $ref: '#/components/schemas/ToolExampleDto'
        pricing:
          description: >-
            Retail price for running this capability. Absent when the capability
            has no active catalogue price — which means the price is unknown,
            not that the capability is free.
          allOf:
            - $ref: '#/components/schemas/ToolPricingDto'
      required:
        - id
        - object
        - category
        - display_name
        - description
        - input_modality
        - output_modality
        - params_schema
        - input_schema
    ErrorDetailDto:
      type: object
      properties:
        message:
          type: string
          example: Model not found
          description: Human-readable error message
        type:
          type: string
          example: invalid_request_error
          description: Error category
          enum:
            - invalid_request_error
            - authentication_error
            - permission_error
            - quota_exceeded
            - rate_limit_error
            - server_error
        code:
          type: string
          example: model_not_found
          nullable: true
          description: >-
            Stable machine-readable error code. Branch on this rather than on
            `message`, which is prose and may be reworded.
        param:
          type: string
          example: model
          nullable: true
          description: >-
            Name of the request parameter that triggered the error. `null` when
            the error is not attributable to one field.
        job_id:
          type: string
          example: job_1hR9xTPZqK4mVLc2nJ7fY5wB
          description: >-
            Handle to work that is ALREADY RUNNING AND ALREADY BILLED, present
            on the few errors that carry one. When it is here, this is not a
            failure to retry — retrying pays twice. Collect the result from `GET
            /v1/images/jobs/{job_id}`, which serves every durable media job
            regardless of modality.


            Two situations produce it. A media generation that outruns the
            gateway's wait answers `504` with `code: "job_timeout"` and keeps
            working. And `POST /v1/audio/speech` answers **500** with `code:
            "artifact_unreadable"` when the speech was generated and settled but
            could not be read back from storage — the audio exists and is paid
            for; only this response failed.


            Declared here rather than per-endpoint because the rule is about the
            FIELD, not the status: if this is present, there is a paid-for
            result to collect. It was undeclared until now, so a client
            generated from this document could not see the one field that
            recovers money already spent.
      required:
        - message
        - type
        - code
        - param
    ToolExampleDto:
      type: object
      properties:
        title:
          type: string
          description: Human-readable label for this worked example.
          example: 800×600 cover
        params:
          type: object
          additionalProperties: true
          description: A `params` object valid against this capability's `params_schema`.
          example:
            width: 800
            height: 600
            fit: cover
      required:
        - title
        - params
    ToolPricingDto:
      type: object
      properties:
        currency:
          type: string
          description: >-
            Always `credits` — the unit customers spend from their wallet. 1
            credit = $0.01.
          enum:
            - credits
          example: credits
        unit:
          type: string
          description: >-
            Billing unit. `per_token` surfaces the `*_per_million` fields below;
            every other unit surfaces exactly one `{unit}_price` field.
          enum:
            - per_token
            - per_request
            - per_image
            - per_second
            - per_minute
            - per_character
            - per_operation
            - per_megapixel
          example: per_operation
        input_per_million:
          type: number
          description: Credits per 1M input tokens. Present when `unit` is `per_token`.
        output_per_million:
          type: number
          description: Credits per 1M output tokens. Present when `unit` is `per_token`.
        audio_input_per_million:
          type: number
          description: >-
            Credits per 1M audio input tokens. Present when `unit` is
            `per_token`.
        audio_output_per_million:
          type: number
          description: >-
            Credits per 1M audio output tokens. Present when `unit` is
            `per_token`.
        image_input_per_million:
          type: number
          description: >-
            Credits per 1M image input tokens. Present when `unit` is
            `per_token`.
        image_output_per_million:
          type: number
          description: >-
            Credits per 1M image output tokens. Present when `unit` is
            `per_token`.
        cached_input_per_million:
          type: number
          description: >-
            Credits per 1M input tokens served FROM the prompt cache — cheaper
            than the input rate. Omitted when no cached rate is published, in
            which case the full input rate applies.
        cache_write_per_million:
          type: number
          description: >-
            Credits per 1M tokens written to the prompt cache at the default
            (5-minute) TTL — DEARER than the input rate. Omitted when no write
            rate is published.
        cache_write_1h_per_million:
          type: number
          description: >-
            Credits per 1M tokens written to the prompt cache at the 1-hour TTL
            — dearer again. Omitted when no 1-hour rate is published.
        request_price:
          type: number
          description: Credits per request. Present when `unit` is `per_request`.
        image_price:
          type: number
          description: Credits per image. Present when `unit` is `per_image`.
        second_price:
          type: number
          description: Credits per second of compute. Present when `unit` is `per_second`.
        minute_price:
          type: number
          description: Credits per minute. Present when `unit` is `per_minute`.
        character_price:
          type: number
          description: Credits per character. Present when `unit` is `per_character`.
        operation_price:
          type: number
          description: Credits per operation. Present when `unit` is `per_operation`.
        megapixel_price:
          type: number
          description: Credits per megapixel. Present when `unit` is `per_megapixel`.
      required:
        - currency
        - unit
  securitySchemes:
    ApiKey:
      type: apiKey
      in: header
      name: Authorization
      description: 'API key in format: Bearer inf_***'

````