# LLM Model Comparison (340+ AI Model Comparison) (`straightforward_hydra/llm-model-comparison-340-ai-model-comparison`) Actor

Compare LLMs (Claude, GPT, Gemini, Grok, Llama, DeepSeek, Mistral, Qwen) on price, context, modality, capabilities and live benchmarks. OpenRouter-powered. No key.

- **URL**: https://apify.com/straightforward\_hydra/llm-model-comparison-340-ai-model-comparison.md
- **Developed by:** [Dev D](https://apify.com/straightforward_hydra) (community)
- **Categories:** AI, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Comparison ⚖️🤖

**Compare large language models — Claude, GPT, Gemini, Grok, Llama, DeepSeek, Mistral, Qwen and more — head-to-head on price, context window, modality, capabilities and live benchmark scores. One call, no API key.**

Choosing between models means juggling pricing pages, context limits, and scattered benchmark leaderboards. This Actor pulls the whole hosted-LLM catalog from **OpenRouter's public model API** and normalizes every model into one clean, comparison-ready row — so you can line up the models you care about and sort them by whatever matters: intelligence, price, context, or Elo.

**Covers every major provider:** Anthropic · OpenAI · Google · xAI · Meta · DeepSeek · Mistral · Qwen · Cohere · and dozens more (340+ models).

---

### Three modes

- **Compare** (default) — name the models you want (`["claude", "gpt-5", "gemini", "grok"]`) and get them lined up and ranked. Broad terms match every variant; exact ids (`anthropic/claude-sonnet-5`) pin one.
- **Search the catalog** — filter all 340+ models by provider, price ceiling, minimum context, modality, reasoning/tools support.
- **Market digest** — a single summary row: price ranges, provider mix, and top models by intelligence and by arena Elo.

### What you get per model

| Field | Example |
|---|---|
| `price_input_per_m` / `price_output_per_m` | **$2.00 / $10.00** per 1M tokens |
| `context_length` / `max_output_tokens` | 1,000,000 / 128,000 |
| `modality` / `input_modalities` | `text+image+file->text` |
| `supports_reasoning` / `supports_tools` | true / true |
| `intelligence_index` · `coding_index` · `agentic_index` | 53.4 · 71.2 · 48.0 *(Artificial Analysis)* |
| `arena_avg_elo` · `arena_best_rank` | 1278 · 3 *(Design Arena)* |
| `knowledge_cutoff` · `created_at` · `url` | … |

### Example — Claude vs GPT vs Gemini vs Grok

```json
{
  "mode": "compare",
  "models": ["claude", "gpt-5", "gemini", "grok"],
  "sortBy": "intelligence"
}
````

Returns each matching model ranked by intelligence index, with price, context, capabilities and benchmark scores side by side.

### Example — cheapest capable models

```json
{
  "mode": "models",
  "maxOutputPricePerM": 5,
  "minContext": 200000,
  "reasoningOnly": true,
  "sortBy": "price_output"
}
```

Every reasoning model with a 200k+ context under $5 / 1M output tokens, cheapest first.

### Run it on a schedule

New models and price changes land constantly. Schedule a daily run to keep a live LLM price/benchmark table in a sheet, dashboard, or your own comparison page — or diff the digest over time to catch new releases and price cuts.

### Notes & limitations

- **No API key** — the OpenRouter model catalog is a public endpoint.
- **Pricing is OpenRouter-listed** (USD per 1M tokens). It mirrors provider pricing closely; some models have long-context surcharge tiers (flagged via `has_long_context_surcharge`). Treat it as OpenRouter's rate, not an official provider quote.
- **Benchmark scores are partial** — Artificial Analysis (intelligence/coding/agentic) and Design Arena (Elo/rank) are present for many but not all models (roughly half); they're surfaced when available and `null` otherwise, never estimated.
- Only models offered via OpenRouter appear; a model not on OpenRouter won't be listed.
- Data source: OpenRouter `/api/v1/models`.

***

#### Keywords

LLM comparison, AI model comparison, compare LLMs, Claude vs GPT, GPT vs Gemini, Grok vs Claude, LLM pricing, LLM price comparison, model context window, LLM benchmarks, intelligence index, arena Elo, OpenRouter, Anthropic Claude, OpenAI GPT, Google Gemini, xAI Grok, Llama, DeepSeek, Mistral, Qwen, model catalog, AI model registry, tokens per dollar, reasoning models, multimodal models.

# Actor input Schema

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

compare = line up the models you name and rank them. models = search/filter the whole catalog. digest = one market-summary row.

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

compare mode: one entry per model or family to line up, matched by name/id. Broad terms match every variant. Examples: "claude", "gpt-5", "gemini", "grok", or exact ids like "anthropic/claude-sonnet-5".

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

Only keep models whose id or name contains this text, e.g. "deepseek", "mini", "vision".

## `provider` (type: `string`):

Only this provider (the id prefix): anthropic, openai, google, x-ai, meta-llama, deepseek, mistralai, qwen, cohere…

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

How to rank the results.

## `modalityOnly` (type: `string`):

Restrict by input modality.

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

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

## `maxOutputPricePerM` (type: `integer`):

Only models whose output price is at or below this many USD per 1M tokens, e.g. 10.

## `reasoningOnly` (type: `boolean`):

Only models that support reasoning / thinking.

## `toolsOnly` (type: `boolean`):

Only models that support tool / function calling.

## `includeDescription` (type: `boolean`):

Include each model's full description text (larger output).

## `includeBenchmarkDetail` (type: `boolean`):

Include the raw per-arena Design Arena benchmark list for each model.

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

Cap on model rows returned.

## Actor input object example

```json
{
  "mode": "compare",
  "models": [
    "claude",
    "gpt-5",
    "gemini",
    "grok"
  ],
  "sortBy": "intelligence",
  "modalityOnly": "",
  "reasoningOnly": false,
  "toolsOnly": false,
  "includeDescription": false,
  "includeBenchmarkDetail": false,
  "maxResults": 200
}
```

# 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-5",
        "gemini",
        "grok"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("straightforward_hydra/llm-model-comparison-340-ai-model-comparison").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-5",
        "gemini",
        "grok",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("straightforward_hydra/llm-model-comparison-340-ai-model-comparison").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 '{
  "models": [
    "claude",
    "gpt-5",
    "gemini",
    "grok"
  ]
}' |
apify call straightforward_hydra/llm-model-comparison-340-ai-model-comparison --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LLM Model Comparison (340+ AI Model Comparison)",
        "description": "Compare LLMs (Claude, GPT, Gemini, Grok, Llama, DeepSeek, Mistral, Qwen) on price, context, modality, capabilities and live benchmarks. OpenRouter-powered. No key.",
        "version": "0.1",
        "x-build-id": "x80djdz5hECZHkvdI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/straightforward_hydra~llm-model-comparison-340-ai-model-comparison/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-straightforward_hydra-llm-model-comparison-340-ai-model-comparison",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/straightforward_hydra~llm-model-comparison-340-ai-model-comparison/runs": {
            "post": {
                "operationId": "runs-sync-straightforward_hydra-llm-model-comparison-340-ai-model-comparison",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/straightforward_hydra~llm-model-comparison-340-ai-model-comparison/run-sync": {
            "post": {
                "operationId": "run-sync-straightforward_hydra-llm-model-comparison-340-ai-model-comparison",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "compare",
                            "models",
                            "digest"
                        ],
                        "type": "string",
                        "description": "compare = line up the models you name and rank them. models = search/filter the whole catalog. digest = one market-summary row.",
                        "default": "compare"
                    },
                    "models": {
                        "title": "Models to compare",
                        "type": "array",
                        "description": "compare mode: one entry per model or family to line up, matched by name/id. Broad terms match every variant. Examples: \"claude\", \"gpt-5\", \"gemini\", \"grok\", or exact ids like \"anthropic/claude-sonnet-5\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "search": {
                        "title": "Search (models mode)",
                        "type": "string",
                        "description": "Only keep models whose id or name contains this text, e.g. \"deepseek\", \"mini\", \"vision\"."
                    },
                    "provider": {
                        "title": "Provider",
                        "type": "string",
                        "description": "Only this provider (the id prefix): anthropic, openai, google, x-ai, meta-llama, deepseek, mistralai, qwen, cohere…"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "intelligence",
                            "arena_elo",
                            "context",
                            "price_input",
                            "price_output",
                            "newest"
                        ],
                        "type": "string",
                        "description": "How to rank the results.",
                        "default": "intelligence"
                    },
                    "modalityOnly": {
                        "title": "Modality filter",
                        "enum": [
                            "",
                            "multimodal",
                            "vision"
                        ],
                        "type": "string",
                        "description": "Restrict by input modality.",
                        "default": ""
                    },
                    "minContext": {
                        "title": "Min context window",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only models with at least this many tokens of context, e.g. 200000."
                    },
                    "maxOutputPricePerM": {
                        "title": "Max output price ($/M tokens)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only models whose output price is at or below this many USD per 1M tokens, e.g. 10."
                    },
                    "reasoningOnly": {
                        "title": "Reasoning models only",
                        "type": "boolean",
                        "description": "Only models that support reasoning / thinking.",
                        "default": false
                    },
                    "toolsOnly": {
                        "title": "Tool-calling models only",
                        "type": "boolean",
                        "description": "Only models that support tool / function calling.",
                        "default": false
                    },
                    "includeDescription": {
                        "title": "Include description",
                        "type": "boolean",
                        "description": "Include each model's full description text (larger output).",
                        "default": false
                    },
                    "includeBenchmarkDetail": {
                        "title": "Include full benchmark detail",
                        "type": "boolean",
                        "description": "Include the raw per-arena Design Arena benchmark list for each model.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on model rows returned.",
                        "default": 200
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
