# AI Model Catalog & API Pricing Tracker (`ranthis/ai-model-catalog-pricing`) Actor

Compare 9,000+ AI models across 200+ providers by API price, context window and capabilities (reasoning, tool calling, vision), and get alerted to price changes between runs. Data from the open models.dev catalog.

- **URL**: https://apify.com/ranthis/ai-model-catalog-pricing.md
- **Developed by:** [RanThis](https://apify.com/ranthis) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 model rows

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## AI Model Catalog & API Pricing Tracker

Find the **cheapest AI model that does what you need** — and know when prices change. One run gives you a clean,
filterable table of **9,000+ models from 200+ providers** (OpenAI, Anthropic, Google, Mistral, DeepSeek, xAI, Bedrock,
Azure, Groq, Together and many resellers) with API prices, context window and capabilities.

### Use cases

- Pick the cheapest model with tool calling + vision + 128k context for a new feature.
- Compare the same model across providers (e.g. one open-weights model on ten hosts) using `canonicalModelId`.
- **Price-change feed:** schedule it daily with *Detect price changes* on, and route rows where
  `priceChange = "changed"` to Slack, email or a spreadsheet through Apify integrations.
- Feed an internal model router or cost dashboard with fresh pricing via API.

### Output

One row per model per provider:

| Field | Example | Meaning |
|---|---|---|
| `provider`, `providerName` | `anthropic`, `Anthropic` | Who serves the model |
| `modelId`, `name` | `claude-opus-4-7`, `Claude Opus 4.7` | Model identifier used in that provider's API |
| `canonicalModelId` | `google/lyria-3-pro-preview` | Same model across providers (when known) |
| `inputPricePer1M`, `outputPricePer1M` | `5`, `25` | USD per 1 million tokens |
| `cacheReadPricePer1M`, `cacheWritePricePer1M` | `0.5`, `6.25` | Prompt-caching prices, if listed |
| `contextLength`, `maxOutputTokens` | `1000000`, `128000` | Token limits |
| `inputModalities`, `outputModalities` | `["text","image","pdf"]` | Supported input/output types |
| `reasoning`, `toolCall`, `structuredOutput`, `attachment`, `openWeights` | `true` | Capabilities |
| `releaseDate`, `lastUpdated`, `knowledgeCutoff` | `2026-04-14` | Dates as listed |
| `priceChange`, `previousPrices` | `changed` | Only with *Detect price changes*: `changed` (price differs from previous run), `new` (model newly added to the catalog) or empty |
| `docs`, `source`, `fetchedAt` | | Provider docs link, data source, UTC time |

### Filters

Providers, text search on model name, required capabilities, required input types (image, audio, video, PDF),
minimum context window, maximum input price, release date, sort order and a result limit.

### Pricing

Pay per result: **$2.00 per 1,000 model rows**, plus **$0.01 per detected price change** (only when *Detect price
changes* is on). A typical filtered query (50–200 models) costs $0.10–$0.40. Use *Max results* or the run's maximum
charge to cap spending.

### Data source and accuracy

Data comes from [models.dev](https://models.dev), an open, community-maintained catalog published under the MIT
license. This Actor fetches it fresh on every run and adds filtering, sorting and change detection. Prices are **as
listed in the catalog, not official quotes** — always confirm on the provider's pricing page (`docs` field) before
committing to a budget. The Actor does not scrape provider websites.

No personal data is collected. Not affiliated with models.dev or any AI provider.

### Feedback

Missing a filter or field? Open an issue on the **Issues** tab — answered within 14 days.

# Actor input Schema

## `providers` (type: `array`):

Provider IDs as used by models.dev, e.g. anthropic, openai, google, mistral, deepseek, xai, groq, amazon-bedrock, azure, openrouter-style resellers. Empty = all providers.

## `search` (type: `string`):

Optional text filter on model ID or name, e.g. "gpt", "claude", "llama".

## `capabilities` (type: `array`):

Only keep models that support all selected capabilities.

## `inputModalities` (type: `array`):

Only keep models that accept all selected input types.

## `minContext` (type: `integer`):

e.g. 128000

## `maxInputPricePer1M` (type: `number`):

Leave empty for no limit.

## `pricedOnly` (type: `boolean`):

Skip models without a listed API price or priced at 0 (local runtimes, subscription plans).

## `releasedAfter` (type: `string`):

Only models released on or after this date.

## `sortBy` (type: `string`):

Order of the results.

## `maxResults` (type: `integer`):

Upper limit of rows saved (and charged).

## `diffWithPrevious` (type: `boolean`):

Saves a snapshot of the whole catalog's prices in a named key-value store in your account (ai-model-catalog-snapshots). Rows are marked "changed" when the price differs from the previous run and "new" when the model was not in the catalog before. Schedule the Actor daily to get a price-change feed.

## Actor input object example

```json
{
  "providers": [
    "anthropic",
    "openai",
    "google"
  ],
  "capabilities": [],
  "inputModalities": [],
  "pricedOnly": true,
  "sortBy": "inputPrice",
  "maxResults": 200,
  "diffWithPrevious": false
}
```

# Actor output Schema

## `overview` (type: `string`):

All results as a table (dataset view "overview").

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "providers": [
        "anthropic",
        "openai",
        "google"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ranthis/ai-model-catalog-pricing").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "providers": [
        "anthropic",
        "openai",
        "google",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ranthis/ai-model-catalog-pricing").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "providers": [
    "anthropic",
    "openai",
    "google"
  ]
}' |
apify call ranthis/ai-model-catalog-pricing --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,ranthis/ai-model-catalog-pricing"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/uy2FfIwvcBPC26WCF/builds/WaIDwaeCzR3cmYUkI/openapi.json