# AI Model Tracker — OpenAI, Anthropic, Google, Mistral (`gochujang/openai-model-tracker`) Actor

Track AI language model releases, pricing, and capabilities across OpenAI, Anthropic, Google, and Mistral. Returns model names, context window, pricing per token, modalities, knowledge cutoff, and release dates. Uses public APIs and documentation. No API key required.

- **URL**: https://apify.com/gochujang/openai-model-tracker.md
- **Developed by:** [Hojun Lee](https://apify.com/gochujang) (community)
- **Categories:** Automation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 item trackeds

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 Tracker — OpenAI, Anthropic, Google, Mistral

**AI Model Tracker** returns current model IDs, context windows, input/output pricing, vision support, function-calling support, and cost tier classification across **OpenAI, Anthropic, Google, Mistral, Cohere, Meta, and Groq** — sourced from the LiteLLM model prices dataset. No API key required. $0.003/model.

The AI model landscape changes weekly. New models drop, pricing shifts, context windows expand. This actor gives you a structured, filterable snapshot of the entire LLM pricing universe — automatable, queryable, and up to date.

***

### Why use AI Model Tracker?

1. **LLM cost comparison** — Before building a production API integration, pull all chat models and sort by `input_cost_per_1m_tokens`. Premium models cost 50x more than budget alternatives — make the decision with data.
2. **New model release monitoring** — Schedule weekly runs and compare the result set against last week's dataset. New `model_id` entries = newly released models. Never miss a release.
3. **Capability-filtered model selection** — Filter to `supports_vision: true` and `minContextWindow: 128000` to find all multimodal long-context models across providers in one query.
4. **AI cost dashboards** — Power internal cost optimization dashboards with live pricing data instead of manually checking 7 provider docs.
5. **Vendor benchmarking** — Track how different providers price equivalent capability tiers (`premium` vs. `standard` vs. `budget`) over time.

***

### How to use

1. Open the actor on Apify Store and click **Try for free**.
2. Set `providers` to the AI companies you want to track (empty = all 7 providers).
3. Set `modesFilter` to focus on a model type (e.g. `["chat"]` for text generation models only).
4. Set `minContextWindow` to filter out short-context models.
5. Click **Start**. Returns structured model records.

***

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `providers` | string\[] | all | AI providers to include (see list below) |
| `modesFilter` | string\[] | all | Model types: `chat`, `embedding`, `image`, `audio`, `completion` |
| `minContextWindow` | integer | `0` | Only return models with at least this many tokens context |

#### Supported providers

| Value | Models |
|-------|--------|
| `openai` | GPT-4o, GPT-4 Turbo, o1, o3, GPT-3.5, … |
| `anthropic` | Claude 4.x, Claude 3.5/3 Opus/Sonnet/Haiku, … |
| `google` | Gemini 2.0, Gemini 1.5 Pro/Flash, … |
| `mistral` | Mistral Large, Mistral Small, Codestral, … |
| `cohere` | Command R+, Command R, … |
| `meta` | Llama 3.x variants |
| `groq` | Groq-hosted models |

***

### Output

```json
{
  "model_id": "gpt-4o",
  "provider": "openai",
  "mode": "chat",
  "context_window_tokens": 128000,
  "max_output_tokens": 4096,
  "input_cost_per_1m_tokens": 5.0,
  "output_cost_per_1m_tokens": 15.0,
  "supports_vision": true,
  "supports_function_calling": true,
  "supports_audio_input": false,
  "cost_tier": "premium",
  "fetched_at": "2026-09-02T10:00:00Z"
}
```

#### Cost tier classification

| Tier | Input cost per 1M tokens | Examples |
|------|--------------------------|----------|
| `budget` | < $1.00 | GPT-3.5, Haiku, Gemini Flash |
| `standard` | $1.00–$5.00 | Sonnet, Gemini Pro, Mistral Large |
| `premium` | > $5.00 | GPT-4o, Claude Opus, Gemini Ultra |

***

### Cost estimation

**Pay-Per-Event: $0.003 per model returned.**

| Use case | Models | Estimated cost |
|----------|--------|----------------|
| All chat models (~200) | 200 | ~$0.60/run |
| OpenAI + Anthropic only (~50) | 50 | ~$0.15/run |
| Weekly new model check | 200 | ~$0.60/week |
| Premium multimodal filter (~20) | 20 | ~$0.06/run |

***

### Example queries

**All chat models:**

```json
{ "modesFilter": ["chat"] }
```

**OpenAI + Anthropic with 128K+ context:**

```json
{ "providers": ["openai","anthropic"], "minContextWindow": 128000 }
```

**Find all vision-capable premium models (filter in code):**

```json
{ "modesFilter": ["chat"] }
```

Then filter results where `supports_vision == true && cost_tier == "premium"`.

***

### FAQ

**How current is the pricing data?**
The LiteLLM model prices dataset is community-maintained and updated frequently. It typically lags official provider announcements by a few days. For production billing, always verify against the provider's official pricing page.

**Does it include fine-tuned model pricing?**
The dataset includes some fine-tuned model pricing where available. Filter by `model_id` containing `"ft:"` or similar to identify fine-tuned entries.

**Can I access non-default providers (DeepSeek, Grok, Azure)?**
Yes — add provider names like `"deepseek"`, `"xai"`, `"azure"` to the `providers` filter. These are available in the underlying dataset but filtered out by default for relevance.

**What does `mode: "embedding"` mean?**
Embedding models convert text to vector representations. They're priced differently (no output cost) and have different context windows than chat models. Use `modesFilter: ["embedding"]` to pull only embedding model pricing.

***

### Related actors

- [Crypto News Sentiment Analyzer](https://apify.com/gochujang/crypto-news-sentiment) — Uses Claude (Anthropic API); this actor helps you choose which Claude model to use
- [PyPI Package Analyzer](https://apify.com/gochujang/pypi-package-analyzer) — Tracks AI library downloads (anthropic, openai, transformers) to complement model tracking
- [GitHub Repo Stats Tracker](https://apify.com/gochujang/github-repo-stats) — Track AI provider GitHub repos (openai/openai-python, anthropics/anthropic-sdk-python)

### Feedback

If this actor helps your AI cost research, a quick review helps others find it: [Leave a review on Apify Store](https://apify.com/gochujang/openai-model-tracker#reviews)

***

**Keywords:** OpenAI model tracker, GPT-4 pricing, Claude pricing, AI model comparison, LLM cost tracker, AI API pricing, GPT model list, Gemini pricing, Anthropic models, AI model context window, tokens per dollar, LLM benchmark comparison, AI provider pricing, latest AI models, AI API cost calculator

# Actor input Schema

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

Filter to specific AI providers (e.g. \['openai', 'anthropic', 'google']). Leave empty for all.

## `modesFilter` (type: `array`):

Filter by model mode: chat, embedding, image, audio. Leave empty for all.

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

Only return models with at least this many tokens of context

## Actor input object example

```json
{
  "minContextWindow": 0
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("gochujang/openai-model-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("gochujang/openai-model-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 '{}' |
apify call gochujang/openai-model-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gochujang/openai-model-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/zBDMv1Mruzd2cdQIK/builds/6TYd8pS57n7AbW8oC/openapi.json