> ## 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.

# List Models

> 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.



## 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.