# LLM Pricing Tracker: Model Prices per Token, All Providers (`transparent_meteorite/llm-pricing-tracker`) Actor

LLM pricing for 400+ models: input and output price per million tokens, cached price, context window, provider endpoints and price-change tracking since your last run. No key.

- **URL**: https://apify.com/transparent_meteorite/llm-pricing-tracker.md
- **Developed by:** [Detroit Web Agent - Open Data](https://apify.com/transparent_meteorite) (community)
- **Categories:** AI, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.58 / 1,000 price row returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## LLM Pricing Tracker: Model Prices per Token, All Providers

LLM pricing for more than 400 AI models in one table: input price and output price per million tokens, cached-input price, context window, tool and reasoning support, the hosts that serve each model, and what changed since your last run. No API key, no login, no proxy.

If you build with language models you already know the problem: prices move every week, the same model is sold by several hosts at different rates, and a pricing page only shows you today. This Actor reads a live public model catalog, converts every rate to US dollars per million tokens, and, if you schedule it, tells you which models got cheaper or more expensive since the previous run.

### Run in 30 seconds

1. Open the **Input** tab. The prefilled keywords (`claude`, `gpt`, `gemini`, `llama`) return the 25 newest matching models.
2. Click **Start**. A default run finishes in a few seconds.
3. Open the **Prices** table in the Output tab, or export as JSON, CSV or Excel.
4. Change the keywords, add a price ceiling, or switch on **One row per provider endpoint** and run again.

### What does this Actor do?

It downloads the current price list of the catalog, keeps the models that match your keywords and filters, sorts them, and returns one flat row per model. Prices in the source are quoted per single token; the Actor multiplies them so every number you see is **US dollars per 1,000,000 tokens**, the unit used on every vendor's pricing page.

Optionally it also fetches every hosting provider behind a model, so you can see that the same open-weight model costs one amount at one host and a different amount at another, along with quantization and recent uptime.

On top of that it keeps a small price snapshot in a named storage in your own Apify account. On the next run each row is marked **new**, **up**, **down** or **unchanged**, with the date the price changed and the previous input and output price. That turns a one-off lookup into a price-drop alert you can send to Slack, a sheet or an email.

| Group | Fields |
|---|---|
| Identity | `model`, `name`, `provider`, `modelUrl` |
| Token prices (USD per 1M tokens) | `inputPricePerM`, `outputPricePerM`, `cachedInputPricePerM`, `cacheWritePricePerM`, `reasoningPricePerM` |
| Other prices (USD per unit) | `imagePriceUsd`, `webSearchPriceUsd`, `requestPriceUsd` |
| Capacity | `contextWindow`, `maxCompletionTokens` |
| Capabilities | `modality`, `inputModalities`, `outputModalities`, `supportsTools`, `supportsReasoning` |
| Flags | `isFree`, `isVariablePrice`, `releasedAt`, `expiresAt` |
| Provider endpoint (optional) | `endpointProvider`, `endpointTag`, `quantization`, `uptime30m`, `discount` |
| Change tracking | `priceChange`, `changedAt`, `previousInputPricePerM`, `previousOutputPricePerM` |
| Run | `scrapedAt` |

Fields that a model does not have are returned as `null`, never as zero, so a missing cache price is not confused with a free one. Models with variable or router pricing are flagged with `isVariablePrice` and have `null` token prices.

### Who uses it

- **Developers choosing a model.** Sort by input price, filter to models with a 200,000-token context window and tool support, and pick the cheapest that fits.
- **Teams watching their AI bill.** Schedule a daily run with **Only models whose price changed** and get a message only when something you depend on moves.
- **Analysts and newsletter writers.** Track how fast prices fall for each model family, using the `changedAt` and previous price fields collected run after run.
- **Procurement and finance.** Export a dated price table for every model your company uses, with the host-level prices behind it.
- **Product builders.** Feed live prices into a calculator, a comparison page or an internal cost dashboard through the API.

### Limits

- Prices are the catalog's published rates, the same ones the gateway charges its own users. A vendor can charge a different amount on its own direct price page, for volume deals, or for a batch tier.
- The catalog lists what is currently available. A model that was removed is not returned and cannot be priced after the fact.
- Change tracking compares your run with your previous run, so the first run only saves a baseline (every row says `new`). Changes show from the second run on. History is kept per Apify account, not per task.
- Image, audio and web-search prices are quoted by the source in US dollars per unit, not per token, and are returned in that unit as `imagePriceUsd`, `webSearchPriceUsd` and `requestPriceUsd`.
- Free models can disappear or be rate limited; `isFree` only tells you the listed price is zero.

### Input

| Field | What it does |
|---|---|
| `models` | Keywords matched against model id and name, one per line. Empty means every model. |
| `providers` | Only models from these makers, for example `openai`, `anthropic`, `google`. |
| `maxItems` | Maximum rows returned. Default 25, up to 5000. |
| `sortBy` | `newest`, `inputPrice`, `outputPrice`, `context` or `name`. Applied before the limit. |
| `maxInputPricePerM` | Keep models at or below this input price in dollars per million tokens. |
| `maxOutputPricePerM` | Keep models at or below this output price. |
| `minContextWindow` | Keep models with at least this many tokens of context. |
| `outputModality` | `text`, `image`, `audio` or `embeddings`. |
| `includeFree` | Untick to hide zero-priced models. |
| `perProviderEndpoints` | One row per hosting provider with that host's own price. |
| `trackChanges` | Save a snapshot and mark each row new, up, down or unchanged. Default on. |
| `onlyChanged` | Return only models whose price differs from your previous run. |

### Example input

Find the cheapest models with a long context window:

```json
{
  "sortBy": "inputPrice",
  "minContextWindow": 200000,
  "outputModality": "text",
  "maxItems": 20
}
```

Compare hosts for one open-weight family:

```json
{
  "models": ["llama"],
  "perProviderEndpoints": true,
  "sortBy": "outputPrice",
  "maxItems": 40
}
```

Daily price-change alert (schedule it, then connect the dataset to Slack or email):

```json
{
  "models": ["claude", "gpt", "gemini"],
  "onlyChanged": true,
  "maxItems": 200
}
```

### Output sample

```json
{
  "model": "openai/example-model",
  "name": "OpenAI: Example Model",
  "provider": "openai",
  "inputPricePerM": 2.5,
  "outputPricePerM": 10,
  "cachedInputPricePerM": 0.25,
  "cacheWritePricePerM": null,
  "reasoningPricePerM": null,
  "imagePriceUsd": null,
  "webSearchPriceUsd": 0.01,
  "requestPriceUsd": null,
  "contextWindow": 1050000,
  "maxCompletionTokens": 128000,
  "modality": "text+image->text",
  "inputModalities": ["text", "image"],
  "outputModalities": ["text"],
  "supportsTools": true,
  "supportsReasoning": true,
  "isFree": false,
  "isVariablePrice": false,
  "releasedAt": "2026-11-17T18:00:32.000Z",
  "expiresAt": null,
  "modelUrl": "https://openrouter.ai/openai/example-model",
  "endpointProvider": null,
  "endpointTag": null,
  "quantization": null,
  "uptime30m": null,
  "discount": null,
  "priceChange": "down",
  "changedAt": "2026-11-20T06:00:03.000Z",
  "previousInputPricePerM": 3,
  "previousOutputPricePerM": 12,
  "scrapedAt": "2026-11-20T06:00:03.000Z"
}
```

The values above are an illustration. Your own run returns the live prices.

### Use cases

- Pick the cheapest model that still has tools, vision or a very long context.
- Get a message the day a model you rely on gets cheaper, or more expensive.
- Compare the hosts of the same open-weight model before you commit to one.
- Build a public or internal LLM price comparison page that updates itself.
- Audit which of the models in your codebase are about to expire or have been replaced.
- Estimate monthly cost: multiply the per-million prices by your token volume in a sheet.

### Pricing

Pay per event, no subscription. Current prices:

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Actor Start | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| Price row returned | $0.00095 | $0.000885 | $0.000755 | $0.000583 | $0.000583 | $0.000583 |

Tier follows your Apify subscription plan.

Apify's free plan includes monthly platform credit that covers test runs.

Examples at the current price (one `model-price` event per result; Free-plan tier):

| You pull | You pay |
|---|---|
| 100 results | $0.095 |
| 1,000 results | $0.95 |
| 10,000 results | $9.50 |

Scheduled runs stay cheap when each run only returns new records.

### Integrations and scheduling

For monitoring, create a Task with your keywords and **Only models whose price changed** switched on, then add a schedule (daily is plenty, prices rarely move more often). Send the dataset to Google Sheets, Slack, email, Make, Zapier or n8n with the Apify integrations, or read it through the REST API.

### Use with the API, n8n, Make, Zapier or AI agents

**API** (one call, returns the rows as JSON):

```bash
curl -X POST "https://api.apify.com/v2/acts/transparent_meteorite~llm-pricing-tracker/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" -H "Content-Type: application/json" -d '{"models":["claude","gpt"],"sortBy":"inputPrice","maxItems":25}'
```

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("transparent_meteorite/llm-pricing-tracker").call(run_input={"models": ["claude", "gpt", "gemini"], "maxItems": 25})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["model"], row["inputPricePerM"], row["outputPricePerM"], row["priceChange"])
```

- **n8n, Make, Zapier:** use the Apify app's "Run Actor" step with actor `transparent_meteorite/llm-pricing-tracker`, paste the input JSON, then map the dataset items to your sheet or message.
- **AI agents (MCP):** connect the Apify MCP server at `https://mcp.apify.com?tools=transparent_meteorite/llm-pricing-tracker` to Claude, Cursor or any MCP client, and your agent can look up live model prices as a tool.

### Fair use and legal

The Actor reads a public, key-free price catalog and does not log in or bypass anything. The prices are factual public information. This is an independent tool and is not affiliated with any model maker or hosting provider. Always confirm the price on the provider's own page before signing a contract.

### FAQ

**Do I need an API key?** No. Neither the source nor the Actor needs one.

**Which providers are covered?** Every maker and host listed in the catalog, which is more than 400 models from the large labs and open-weight hosts. Use `providers` to narrow it down.

**Why is a price `null`?** The model does not have that price, or its price is variable (router and auto models). Zero always means free.

**How do I get price changes?** Keep **Track price changes** on and run at least twice. The first run saves the baseline. From then on `priceChange` is `up`, `down` or `unchanged`, and `changedAt` is the time the Actor first saw the new price.

**Can I get the price of one model at every host?** Yes. Set `models` to its name and turn on **One row per provider endpoint**.

**Are batch or discounted tiers shown?** Batch variants that the catalog lists as separate models appear as their own rows, usually with a `:batch` suffix in the id. The `discount` field shows a host's listed discount when there is one.

**Why do I get fewer rows than `maxItems`?** Fewer models matched your filters. The run status says which filters were active.

**Are the prices real-time?** They are read live at the start of every run.

### Support

Found a model that reads wrongly, or need another field? Open an issue on the Issues tab with the run URL and the model id.

### Related actors

- [Developer Signals: Hacker News, Show HN, npm and PyPI Tracker](https://apify.com/transparent_meteorite/developer-signals) for the launches and library releases around the models you track.
- [Company News Monitor](https://apify.com/transparent_meteorite/company-news-monitor) for news alerts on AI vendors and keywords.
- [Google Trends Scraper](https://apify.com/transparent_meteorite/google-trends-scraper) to see which models and brands people search for.

### Changelog

- **0.1**: First private build. Prices per million tokens, filters, provider endpoints, price-change tracking.

# Actor input Schema

## `models` (type: `array`):

Keywords matched against model id and name, one per line: claude, gpt-5, llama, deepseek. Leave empty for every model.

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

Model maker prefixes, for example openai, anthropic, google, meta-llama, mistralai. Leave empty for all.

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

Stops after this many rows. Each row is billed once.

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

Order of the rows before the limit is applied. Use a price sort to find the cheapest models.

## `maxInputPricePerM` (type: `number`):

Keep only models whose input price is at or below this. Example: 1 keeps models under $1 per million input tokens.

## `maxOutputPricePerM` (type: `number`):

Keep only models whose output price is at or below this.

## `minContextWindow` (type: `integer`):

Keep only models that accept at least this many tokens, for example 200000.

## `outputModality` (type: `string`):

Keep only models that return this kind of output.

## `includeFree` (type: `boolean`):

Untick to hide models priced at $0.

## `perProviderEndpoints` (type: `boolean`):

The same model is often hosted by several providers at different prices. Tick to get one row per host with its own price, quantization and uptime.

## `trackChanges` (type: `boolean`):

Saves a price snapshot in your account and marks every row as new, up, down or unchanged versus your previous run.

## `onlyChanged` (type: `boolean`):

Return only models whose input or output price differs from your previous run. Best with a daily schedule.

## Actor input object example

```json
{
  "models": [
    "claude",
    "gpt",
    "gemini",
    "llama"
  ],
  "maxItems": 25,
  "sortBy": "newest",
  "outputModality": "",
  "includeFree": true,
  "perProviderEndpoints": false,
  "trackChanges": true,
  "onlyChanged": false
}
```

# Actor output Schema

## `prices` (type: `string`):

No description

# 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 = {
    "models": [
        "claude",
        "gpt",
        "gemini",
        "llama"
    ],
    "maxItems": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("transparent_meteorite/llm-pricing-tracker").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 = {
    "models": [
        "claude",
        "gpt",
        "gemini",
        "llama",
    ],
    "maxItems": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("transparent_meteorite/llm-pricing-tracker").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 '{
  "models": [
    "claude",
    "gpt",
    "gemini",
    "llama"
  ],
  "maxItems": 25
}' |
apify call transparent_meteorite/llm-pricing-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,transparent_meteorite/llm-pricing-tracker"
        }
    }
}
```

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/3Uwfi9ybDXvUBx5tu/builds/yeMyPOqrbAfLyeSld/openapi.json
