# LLM Radar - AI Model Pricing, Benchmarks & Status Actor API (`datahq/llm-radar`) Actor

Real-time pricing for 110+ AI models, live LMSYS Arena ELO scores, and provider operational status from 11 providers. One API call.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 Radar - AI Model Pricing & Status Hub

**The most comprehensive LLM intelligence API** - Get real-time pricing for 115 AI models and live operational status from 11 providers in a single API call.

### ✨ Why LLM Radar?

Building AI applications? You need to know:

- 💰 **How much does each model cost?** (input/output tokens, cached, batch pricing)
- 🚨 **Is the API up right now?** (real-time operational status)
- 🏆 **How good is the model?** (Live LMSYS Arena ELO, Rank, & Vote counts)
- 📊 **Which model is best for my task?** (capability scores from Costbase)

**LLM Radar gives you all of this in one structured JSON response.**

### 🚀 Features

- **Live LMSYS Benchmarks**: Automatically fetches the latest ELO ratings, ranks, and vote counts from LMSYS Chatbot Arena.
- **115+ Models**: Covers OpenAI, Anthropic, Google, Amazon Bedrock, Mistral, and more.
- **Unified Pricing**: Normalized pricing data (per 1M tokens) across all providers.
- **Provider Status**: Real-time status checks for 8 major API providers.

***

### 🏢 Supported Providers & Models

| Provider | Models | Highlights |
|----------|--------|------------|
| **OpenAI** | 30 | GPT-5.1, GPT-5, GPT-4.1, o1, o3-mini, DALL-E, Whisper |
| **Mistral** | 17 | Large, Medium, Small, Codestral, Pixtral, Ministral |
| **Google** | 11 | Gemini 2.5, 2.0, 1.5 Flash/Pro, Imagen, Veo |
| **Groq** | 11 | Llama 3.3/3.2/3.1, Mixtral, Gemma (ultra-fast) |
| **Cohere** | 10 | Command R+, R, Embeddings, Rerank |
| **Amazon** | 8 | Titan, Nova Pro/Lite/Micro, Bedrock Embeddings |
| **xAI** | 8 | Grok 3, Grok 2, Grok Vision |
| **Anthropic** | 7 | Claude Opus/Sonnet/Haiku 4.5, 4, 3.5 |
| **Together** | 6 | Llama 3.1 405B/70B, Qwen 2.5, DeepSeek R1 |
| **Fireworks** | 5 | Llama 3.3, Qwen 2.5, DeepSeek V3 (serverless) |
| **DeepSeek** | 2 | DeepSeek V3, Reasoner R1 |

**Total: 115 models with detailed pricing & capability scores**

***

### 📊 What You Get

#### 1. Comprehensive Pricing Data

```json
{
  "models": [
    {
      "model_id": "gpt-4.1",
      "provider": "openai",
      "display_name": "GPT-4.1",
      "model_type": "text",
      "tier": "flagship",
      "pricing": {
        "text": {
          "input_per_million": 30.00,
          "output_per_million": 60.00,
          "cached_input_per_million": 15.00
        },
        "context_window": 128000,
        "currency": "USD"
      },
      "benchmarks": {
        "arena_elo": 1287,
        "rank": 24,
        "votes": 24834,
        "coding": 0.94,
        "math": 0.92,
        "source": "LMSYS Chatbot Arena"
      }
    }
  ]
}
```

#### 2. Real-Time Provider Status

```json
{
  "status": [
    {
      "provider": "openai",
      "status": "operational",
      "description": "All Systems Operational",
      "latency_p50_ms": 145
    },
    {
      "provider": "anthropic",
      "status": "degraded",
      "description": "Increased API Latency"
    }
  ]
}
```

#### 3. Summary Statistics

```json
{
  "summary": {
    "total_models": 115,
    "providers": {
      "openai": 30,
      "mistral": 17,
      "google": 11,
      "groq": 11,
      "cohere": 10,
      "xai": 8,
      "anthropic": 7,
      "amazon": 8,
      "together": 6,
      "fireworks": 5
    },
    "status_summary": {
      "operational": ["openai", "google", "groq"],
      "degraded": ["anthropic"],
      "outage": []
    }
  }
}
```

***

### 💰 Data Fields Included

| Category | Fields | Description |
|----------|--------|-------------|
| **Pricing** | `input_per_million`, `output_per_million`, `cached_input_per_million` | Token costs in USD |
| **Capability Scores** | `coding`, `creative`, `analysis`, `translation`, `math`, `speed` | 0-1 scale performance ratings |
| **Model Info** | `tier`, `release_date`, `context_window`, `max_output_tokens` | Model specifications |
| **Status** | `operational`, `degraded`, `outage`, `unknown` | Real-time API health |

***

### 🎯 Model Tiers

| Tier | Description | Example Models |
|------|-------------|----------------|
| **flagship** | Best performance, highest cost | GPT-5.1, Claude Opus 4.5, Grok 3 |
| **standard** | Balanced performance/cost | GPT-5-mini, Claude Sonnet, Gemini 2.0 |
| **budget** | Cost-optimized | GPT-5-nano, Claude Haiku, Ministral 3B |
| **premium** | Specialized (reasoning, etc.) | o1, o3-mini, DeepSeek Reasoner |

***

### 🔧 Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `providers` | array | `["all"]` | Which providers to include |
| `dataTypes` | array | `["pricing", "status"]` | What data to fetch |
| `forceRefresh` | boolean | `false` | Bypass cache for fresh pricing |

#### Example Input

```json
{
  "providers": ["openai", "anthropic", "groq"],
  "dataTypes": ["pricing", "status"],
  "forceRefresh": false
}
```

***

### 🚀 Use Cases

#### 1. Cost Calculator

```javascript
const { models } = await llmRadar.getData();
const gpt5 = models.find(m => m.model_id === 'gpt-5.1');
const cost = (tokens / 1_000_000) * gpt5.pricing.text.input_per_million;
```

#### 2. Find Best Model for Task

```javascript
const { models } = await llmRadar.getData();
const bestForCoding = models
  .filter(m => m.benchmarks?.coding)
  .sort((a, b) => b.benchmarks.coding - a.benchmarks.coding)[0];
console.log(`Best for coding: ${bestForCoding.display_name}`);
```

#### 3. Smart Model Router

```javascript
const { models, status } = await llmRadar.getData();
const operational = status.filter(s => s.status === 'operational').map(s => s.provider);
const cheapest = models
  .filter(m => operational.includes(m.provider) && m.tier === 'budget')
  .sort((a, b) => a.pricing.text.input_per_million - b.pricing.text.input_per_million)[0];
```

#### 4. Status Dashboard

```javascript
const { status, summary } = await llmRadar.getData();
console.log(`Operational: ${summary.operational_count}/${status.length}`);
status.forEach(s => showBadge(s.provider, s.status));
```

***

### ⚡ Performance

- **Fast execution**: ~5 seconds per run
- **Pricing cached**: 30 days (prices rarely change)
- **Status fresh**: Always real-time from provider APIs
- **Minimal compute**: Low resource usage per run

***

### 📡 API Access

After running, access your data via the Apify Dataset API:

```bash
curl "https://api.apify.com/v2/datasets/{DATASET_ID}/items" \
  -H "Authorization: Bearer YOUR_TOKEN"
```

Or use the Apify SDK:

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('llm-radar').call();
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].summary); // { total_models: 96, ... }
```

***

### 🔄 Data Freshness

| Data Type | Cache Duration | Notes |
|-----------|---------------|-------|
| Pricing & Models | 30 days | From curated database |
| Status | Always fresh | Fetched from provider APIs each run |

Use `forceRefresh: true` to bypass pricing cache.

***

### ⚡ Optimized Usage

#### 1. 🚨 Status Monitor (Save Costs)

**Use Case**: Check if APIs are down every 15 minutes.
**Config**:

```json
{
  "dataTypes": ["status"],
  "providers": ["all"]
}
```

**Output**: Only returns status array. Minimal data transfer.

#### 2. 💰 Pricing & Benchmarks (Full Data)

**Use Case**: Update your internal database with latest prices and ELO scores.
**Config**:

```json
{
  "dataTypes": ["pricing"],
  "forceRefresh": true
}
```

### 📈 Historical Data

The actor automatically snapshots data daily:

- **Storage**: Key-Value Store
- **Key Format**: `HISTORY_YYYY_MM_DD`
- **Content**: Full pricing & status snapshot

### 🏷️ Tags

`llm` `ai-pricing` `openai` `anthropic` `claude` `gpt-5` `gemini` `groq` `mistral` `cohere` `deepseek` `grok` `benchmarks` `lmsys` `elo` `status-monitor` `cost-calculator` `model-comparison`

***

### 📄 License

ISC

### 👤 Author

Built by [Raihan K.](https://github.com/raaihank)

# Actor input Schema

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

Which providers to scrape. Use 'all' for all providers.

## `dataTypes` (type: `array`):

Which data categories to fetch

## `forceRefresh` (type: `boolean`):

Bypass cache and fetch fresh data

## `proxyConfiguration` (type: `object`):

Proxy settings for scraping

## `webhookUrl` (type: `string`):

Webhook URL for completion/error notifications

## Actor input object example

```json
{
  "providers": [
    "all"
  ],
  "dataTypes": [
    "pricing",
    "benchmarks",
    "status"
  ],
  "forceRefresh": false
}
```

# Actor output Schema

## `allData` (type: `string`):

Complete pricing and status data for all providers

## `modelsOnly` (type: `string`):

Just the model pricing data

## `statusOnly` (type: `string`):

Real-time operational status

## `summary` (type: `string`):

Quick overview of models and status counts

# 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("datahq/llm-radar").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("datahq/llm-radar").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 datahq/llm-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datahq/llm-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5793FPIzpbeFRNfAW/builds/0rHZc7LHcnRoDAteg/openapi.json