# LLM Model & Pricing Scraper | $3/1K (`datawell/llm-models-pricing`) Actor

Track 400+ AI models with current prices per million tokens, context lengths, tool support and modalities. Plus a price comparison across every provider hosting the same model — the same model can cost 10x more elsewhere. No API key.

- **URL**: https://apify.com/datawell/llm-models-pricing.md
- **Developed by:** [datawell](https://apify.com/datawell) (community)
- **Categories:** AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## LLM Model & Pricing Scraper

Track **400+ AI models** with current prices, context lengths and capabilities —
and compare what the *same model* costs across every provider hosting it.

No API key. No account. Data straight from OpenRouter's public catalogue.

***

### Why this exists

Model prices change weekly, new models appear almost daily, and the same model
can cost **ten times more** at one provider than another. Nobody publishes that
comparison in a form you can put in a spreadsheet.

The price comparison mode returns one row per provider per model, with the price,
the latency and the quantisation level — so you can see not just who is cheapest,
but what you give up for it.

***

### What you can extract

| Mode | What you get |
|---|---|
| **Model catalogue with prices** | Every model with input and output price per million tokens, context length, modalities, tool support, reasoning, knowledge cutoff |
| **Price comparison across providers** | One row per provider hosting a model: price, context limit, quantisation, latency and uptime |
| **Provider directory** | All 100+ providers with headquarters and datacentre locations |

***

### Quick start

1. Pick **Model catalogue with prices**.
2. Optionally filter by lab, price, context length or tool support.
3. Click **Start**, download as CSV or Excel.

***

### Example inputs

**The full catalogue, cheapest first**

```json
{
  "mode": "models",
  "sortBy": "priceAsc",
  "maxItems": 500
}
```

**Models you can build agents on, with big context**

```json
{
  "mode": "models",
  "toolCallingOnly": true,
  "minContextLength": 200000,
  "sortBy": "priceAsc"
}
```

**Everything from one lab**

```json
{
  "mode": "models",
  "authors": ["anthropic", "openai", "google"],
  "sortBy": "newest"
}
```

**Find the cheapest provider for a model**

```json
{
  "mode": "providerPricing",
  "authors": ["deepseek"],
  "maxItems": 200
}
```

**Free models only**

```json
{
  "mode": "models",
  "freeOnly": true
}
```

***

### Output fields

#### Models

| Field | Description |
|---|---|
| `name`, `modelId`, `author` | What it is and who built it |
| `pricePromptPerMillion` | **Dollars per million input tokens** |
| `priceCompletionPerMillion` | Dollars per million output tokens |
| `priceCacheReadPerMillion`, `priceCacheWritePerMillion` | Caching rates — decides whether caching pays off |
| `contextLength`, `maxCompletionTokens` | How much fits in, how much comes out |
| `inputModalities`, `outputModalities` | text, image, file, audio |
| `supportsTools` | Whether you can build agents on it |
| `supportsReasoning`, `reasoningMandatory` | Explicit reasoning support |
| `supportsStructuredOutput` | Whether it can be forced into a JSON schema |
| `supportedParameters` | Every API parameter the model accepts |
| `knowledgeCutoff` | How current the training data is |
| `huggingFaceId` | Where the open weights live, if published |
| `isModerated`, `isFree`, `createdAt`, `expirationDate` | Status fields |

#### Price comparison

| Field | Description |
|---|---|
| `modelName`, `provider` | Which model at which provider |
| `pricePromptPerMillion`, `priceCompletionPerMillion` | What that provider charges |
| `quantization` | How much the model was compressed — the hidden quality trade-off |
| `contextLength`, `maxPromptTokens`, `maxCompletionTokens` | Limits at this provider |
| `latencyLast30m`, `uptimeLast30m` | Recent performance |

***

### Limits

- **Prices are snapshots.** They change often; schedule a run to build a history.
- **Free models rarely have third-party providers**, so the comparison mode
  returns little for them.
- **The comparison mode makes one request per model**, so filtering first keeps
  runs fast.
- **Latency and uptime are OpenRouter's measurements**, not independent tests.

***

### FAQ

**Do I need an API key?**
No. The catalogue endpoints are public.

**Why do prices differ between providers for the same model?**
Different hardware, different quantisation, different margins. That is exactly
what the comparison mode makes visible.

**What is quantisation and why should I care?**
It is how much the model was compressed to run cheaper. Lower precision costs
less and can answer slightly worse — the column lets you weigh that.

**Can I track price changes over time?**
Yes — schedule the run and each dataset becomes a snapshot.

**What formats can I export?**
CSV, Excel, JSON, XML, or straight from the Apify API.

***

### Source

Data comes from [OpenRouter](https://openrouter.ai/)'s public model catalogue,
which aggregates offerings from over 100 inference providers.

# Actor input Schema

## `mode` (type: `string`):

The model catalogue, a price comparison across providers, or the provider directory.

## `searchQuery` (type: `string`):

Filter by name, model ID or description, e.g. 'vision', 'sonnet', 'coding'.

## `authors` (type: `array`):

Only models from these labs, e.g. anthropic, openai, google, meta-llama, mistralai, deepseek, qwen.

## `freeOnly` (type: `boolean`):

Only models that cost nothing per token. Note: free models usually have no third-party providers, so the price comparison mode returns little.

## `toolCallingOnly` (type: `boolean`):

Only models that support function and tool calling — the ones you can build agents on.

## `minContextLength` (type: `integer`):

Only models with at least this many tokens of context, e.g. 128000.

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

How to order the catalogue.

## `maxItems` (type: `integer`):

How many records to return.

## Actor input object example

```json
{
  "mode": "models",
  "searchQuery": "claude",
  "authors": [
    "anthropic"
  ],
  "freeOnly": false,
  "toolCallingOnly": false,
  "sortBy": "name",
  "maxItems": 500
}
```

# Actor output Schema

## `results` (type: `string`):

Model rows carry prices per million tokens, context length and capabilities. Comparison rows carry one line per provider hosting a model, with price, latency and quantisation.

## `resultsCsv` (type: `string`):

The same rows as a CSV download, ready for Excel or Google Sheets.

# 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 = {
    "authors": [
        "anthropic"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datawell/llm-models-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 = { "authors": ["anthropic"] }

# Run the Actor and wait for it to finish
run = client.actor("datawell/llm-models-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 '{
  "authors": [
    "anthropic"
  ]
}' |
apify call datawell/llm-models-pricing --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datawell/llm-models-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/6okmuoZLbLhYyfhDf/builds/qQdTBLyCsayipckpp/openapi.json