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

# Models: list

> List every model Argus supports, with pricing.

Two families: the curated VLMs served by the locate methods (per-token
pricing; pass their id as `model`) and the Axilio model line behind
screenshots:detect (per-page pricing; selected via `ocr_engine` /
`inference_type` — lite is the free engine, pro is premium).

Public: no API key required (it's a catalog of model names and public
prices, nothing sensitive), so a client can discover supported models
before it holds credentials.

List every model Argus serves, with live pricing. The catalog is public, so
this request does not need an API key.

The catalog has two families:

* **Vision-language models** (`type: "vlm"`) answer the locate operations. Pass
  one as `model` to [Screenshots: locate](/api-reference/argus/screenshots-locate)
  or [Elements: locate](/api-reference/argus/elements-locate).
  They bill per token.
* **Axilio models** (`axilio/argus-*`) run behind
  [Screenshots: detect](/api-reference/argus/screenshots-detect). You select
  them with `ocr_engine` and `inference_type`, not by ID. They bill per page,
  where one screenshot is one page.

A locate request with a model ID that isn't in this list is rejected with
`400` before anything is billed. See [Models](/drivers/models) for how the
driver picks each one.


## OpenAPI

````yaml api-reference/openapi-argus.json GET /api/v1/models
openapi: 3.1.0
info:
  title: Argus
  version: 2.0.0
servers:
  - url: https://argus.axilio.ai
    description: Production
security: []
tags:
  - name: Elements
  - name: Models
  - name: Screenshots
paths:
  /api/v1/models:
    get:
      tags:
        - Models
      summary: List Models
      description: |-
        List every model Argus supports, with pricing.

        Two families: the curated VLMs served by the locate methods (per-token
        pricing; pass their id as `model`) and the Axilio model line behind
        screenshots:detect (per-page pricing; selected via `ocr_engine` /
        `inference_type` — lite is the free engine, pro is premium).

        Public: no API key required (it's a catalog of model names and public
        prices, nothing sensitive), so a client can discover supported models
        before it holds credentials.
      operationId: list_models
      responses:
        '200':
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/SupportedModelsResponse'
          description: Successful Response
components:
  schemas:
    SupportedModelsResponse:
      description: >-
        Response for GET /models.


        Lists every model Argus supports, each with its final post-markup

        pricing: the curated VLMs for the element-locator task (per-token

        pricing; pass their id as `model` to POST /screenshots:locate or

        POST /elements:locate) and the Axilio

        model line behind POST /screenshots:detect (per-page pricing; selected
        via the

        `ocr_engine` and `inference_type` request fields — lite = the free

        engine, pro = premium). Lets a client compare cost and validate

        `find(model=...)` up front instead of round-tripping to /locate and

        getting a 400.


        The VLM set is curated: `/locate` enforces it — an unsupported model is

        rejected, so this is the authoritative allowlist, not just advisory.

        The Axilio ids are not /locate targets.


        Shaped like a standard /v1/models response ({object: "list", data:
        [...]}).
      properties:
        data:
          description: Supported models, sorted by id.
          items:
            $ref: '#/components/schemas/ModelInfo'
          title: Data
          type: array
        object:
          const: list
          default: list
          title: Object
          type: string
      required:
        - data
      title: SupportedModelsResponse
      type: object
    ModelInfo:
      description: >-
        One supported model and its pricing, as a standard /v1/models catalog
        row.
      properties:
        context_window:
          description: Maximum context window, in tokens.
          title: Context Window
          type: integer
        id:
          description: >-
            Model identifier, e.g. 'anthropic/claude-sonnet-4.5' or
            'axilio/argus-ocr-pro-1'. VLM ids are passed as `model` to the
            locate methods; Axilio ids identify the engine behind POST
            /screenshots:detect calls (selected via `ocr_engine` /
            `inference_type`) and are what usage rows are labeled with.
          title: Id
          type: string
        name:
          description: Human-readable model name.
          title: Name
          type: string
        object:
          const: model
          default: model
          title: Object
          type: string
        owned_by:
          description: Model provider, e.g. 'anthropic' or 'axilio'.
          title: Owned By
          type: string
        pricing:
          $ref: '#/components/schemas/ModelPricing'
        type:
          description: >-
            Model type: 'vlm' for the vision-language models served by the
            locate methods (POST /screenshots:locate, POST /elements:locate);
            'detect', 'ocr', and 'vision' for the Axilio model line behind POST
            /screenshots:detect.
          title: Type
          type: string
      required:
        - id
        - name
        - owned_by
        - type
        - context_window
        - pricing
      title: ModelInfo
      type: object
    ModelPricing:
      description: |-
        The customer's billed rates in USD.

        VLMs price per token (input/output); the Axilio model line prices per
        page, where one screenshot is one page — so per_page reads as the price
        of one call. A rate is "0" when that unit is free for the model.
      properties:
        input:
          description: USD per input token.
          title: Input
          type: string
        output:
          description: USD per output token.
          title: Output
          type: string
        per_page:
          anyOf:
            - type: string
            - type: 'null'
          description: >-
            USD per page (one screenshot = one page) for the per-page-billed
            Axilio models. Absent for per-token models.
          title: Per Page
      required:
        - input
        - output
      title: ModelPricing
      type: object

````

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