# OpenRouter Models Scraper · Pricing, Providers & Usage (`data_wiki/openrouter-models-scraper`) Actor

Compare every AI model on OpenRouter in one list. See token prices, context size, provider speed, uptime and usage rankings. No API key or login needed. Great for picking the cheapest, fastest model and tracking price changes.

- **URL**: https://apify.com/data_wiki/openrouter-models-scraper.md
- **Developed by:** [Data WiKi](https://apify.com/data_wiki) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### 🚀 What is OpenRouter Models Scraper?

OpenRouter Models Scraper is an Apify Actor that collects the public OpenRouter model catalog into tables: token prices, context size, capabilities, provider speed, uptime, weekly usage and benchmark scores. It needs no OpenRouter API key or login, and it saves every model as soon as it is ready.

- **No key, no login:** it reads the public data that any visitor sees on [openrouter.ai](https://openrouter.ai).
- **One row per model variant:** get the openrouter models list with prices per million tokens, or pick models by id, page link or author.
- **Provider detail on request:** add every provider's price, latency, throughput, uptime and data policy per model.
- **Live results:** the Output tab fills while the run is going, and the parts of each model are also saved to separate tables.
- **Easy export:** download JSON, CSV, Excel, XML or HTML, or read the dataset through the API.

### 📊 What data can you extract from OpenRouter?

Each row describes one model variant, and prices are in USD per million tokens. The openrouter models pricing fields hold input, output, blended 3:1 and cache prices. Cache, reasoning, audio, image and web search prices complete the openrouter ai model pricing when the site lists them. All prices use USD per million tokens, so an llm token price comparison needs no unit conversion. Copy the openrouter model prices into a spreadsheet or a dashboard.

| Field | Description | Example |
|---|---|---|
| `id`, `name`, `author`, `url` | Model id you pass to the OpenRouter API, model name, author and model page link | `author/model-name` |
| `variant`, `status` | Model variant and its state (`ok`, `router`, `no_endpoint`, `disabled`, `deranked`, `status_<code>`) | `ok` |
| `context_length`, `max_output_tokens`, `max_input_tokens` | Context window and token limits of the top provider | `128000` |
| `input_modalities`, `output_modalities` | What the model accepts and returns | `["text", "image"]` |
| `is_free` | Whether the model costs nothing per token | `false` |
| `pricing` | Input, output, blended 3:1, cache read and write, reasoning, audio, image, web search and discount | `{"input_per_m_tokens": 0.1}` |
| `pricing_details`, `pricing_raw_per_token` | The price lines shown on the model page and the raw per-token values | list or object |
| `capabilities` | Tools, reasoning, structured outputs, web search, file, audio, video and image input | `{"supports_tools": true}` |
| `top_provider` | Provider name, quantization, region, p50 latency and throughput, data policy | `{"name": "Provider"}` |
| `rank_by_weekly_tokens`, `usage_last_week` | Weekly token rank and last week's requests, tokens and tool calls | `7` |
| `category_rankings` | Rank and share per usage category | list |
| `benchmarks` | Intelligence, coding and agentic indexes and a design score | `{"coding_index": 40}` |
| `description`, `created_at`, `updated_at`, `knowledge_cutoff`, `deprecation_date`, `hugging_face_id`, `hugging_face_url`, `model_family`, `instruct_type`, `warning_message`, `short_name`, `author_name`, `permaslug`, `model_context_length` | Descriptive details of the model | text |
| `providers`, `provider_count`, `effective_pricing` | Every provider endpoint with price, speed, uptime and data policy (with the `providers` extra) | list |
| `uptime` | Uptime and availability over three days, hourly (with the `uptime` extra) | object |
| `usage_last_30d`, `usage_daily` | 30-day totals and one entry per day (with the `usage` extra) | list |
| `top_apps` | Top public apps that use the model (with the `apps` extra) | list |
| `benchmark_scores` | Benchmark scores per provider (with the `benchmarks` extra) | object |
| `scraped_at`, `error`, `errors` | Time the row was saved, and error details | text |

A field the site does not publish for a model stays empty (`null`). The `pricing_details` field keeps the openrouter pricing per model lines as the model page shows them. The overview and capabilities views make an openrouter models comparison sheet.

The providers extra gives one row per provider with its own price, quantization and region. That suits an llm api provider comparison. The latency percentiles (p50, p95, p99) suit an llm latency comparison. The providers table lets you build openrouter provider rankings by latency or uptime. The benchmark fields support an llm benchmark comparison.

The field `rank_by_weekly_tokens` gives the openrouter models ranking by weekly tokens, and `category_rankings` adds the rank per usage category.

Each run also builds an openrouter models dataset from six extra tables: `providers`, `daily_usage`, `top_apps`, `benchmarks`, `rankings` and `uptime`. They hold one row per provider, day, app, benchmark, category or hour, and each row carries `model_id` and `model_name`.

### 💡 Use cases for OpenRouter model data

The columns fit any ai model comparison that needs real prices and speeds instead of guesses. For an openrouter pricing scraper view, read only the `pricing` columns.

- **Compare LLM models before you choose one:** put price, context size and capabilities of several models in one table.
- **Build an ai model pricing comparison:** sort by "Cheapest first" and read `pricing.input_per_m_tokens` and `pricing.output_per_m_tokens`.
- **Find the cheapest LLM API:** read the price of every provider endpoint of one model in the `providers` table.
- **Pick the fastest LLM API provider:** compare `latency_p50_ms`, `throughput_p50_tps` and `uptime_today_pct` per provider.
- **Shortlist the best LLM for coding:** sort by "Best at coding" and read the coding index and `benchmark_scores`.
- **See the most used AI models:** read `rank_by_weekly_tokens`, `usage_daily`, `category_rankings` and `top_apps`.
- **Feed your own AI model catalog:** load the flat tables into a database, a sheet or a dashboard.
- **Check context size limits:** sort by "Largest context first" for an llm context window comparison across models.
- **Run an LLM price tracker:** schedule the Actor and compare the datasets of different runs, because one run stores only the current prices.

### 🛠️ How to scrape OpenRouter models

1. Create a free Apify account and open this openrouter scraper in Apify Console.
2. Add model ids, page links or author names to **Models, authors or links**, or leave the list empty for the whole catalog.
3. Pick a **Sort order** and set **Max models** (the limit applies to each entry in the list).
4. Choose the **Extra data per model** you need, for example providers and uptime.
5. Click **Start** and watch the Output tab fill while the run is going.
6. Download the dataset as JSON, CSV, Excel, XML or HTML.

To find the cheapest llm api provider for one model, put only that model's id in the list and keep the `providers` extra. Leave the list empty to get an openrouter all models list in a single run.

### 💰 How much does it cost to scrape OpenRouter models?

OpenRouter Models Scraper uses pay per event pricing. Each model saved to the default dataset is one `main_result` event. A run also pays one `apify-actor-start` event of $0.00005 for its 1,024 MB of memory. Apify platform usage (compute) is billed on top of the events above.

| Apify plan tier | Price per 1,000 models | Price per model |
|---|---|---|
| Free | $1.00 | $0.001 |
| Bronze | $0.90 | $0.0009 |
| Silver | $0.80 | $0.0008 |
| Gold, Platinum, Diamond | $0.70 | $0.0007 |

Example: 500 models on the Free tier cost 500 x $0.001 = $0.50 for results, plus $0.00005 for the start, which is $0.50005 before platform usage. The same 500 models on the Gold tier cost 500 x $0.0007 = $0.35, plus $0.00005 for the start, which is $0.35005 before platform usage.

Rows for inputs that matched no model and the six extra tables are not billed as results. You can set a spend limit on a run, and the Actor stops cleanly when it is reached. See the Pricing tab of the Actor for the current numbers.

### ⬇️ Input

All fields are optional. With an empty `urls` list the Actor returns the top 10 models of the week, sorted by `top-weekly`, with all five extras (slower). The form is prefilled with two example entries. Clear `extraData` for catalog fields only.

| Field | Meaning |
|---|---|
| `urls` | Model ids (`openai/gpt-4o-mini`), model page links or author names (`anthropic`, `google/*`). Empty means the whole catalog. |
| `search` | Keyword, like the search box on openrouter.ai/models. |
| `sort` | Order of the models, for example `top-weekly` (default), `pricing-low-to-high`, `throughput-high-to-low`, `latency-low-to-high`, `context-high-to-low` or `coding-high-to-low`. It also decides which models are kept when you set a limit. |
| `maxItems` | Models to save for each entry in `urls`. Default 10 in the input form, `0` means all. With an empty list it limits the whole catalog. Three authors with `20` give up to 60 models. |
| `extraData` | Any of `providers`, `uptime`, `usage`, `apps`, `benchmarks`. Default: all five (slower). Clear the field for catalog fields only. |
| `proxyConfiguration` | Optional. No proxy is used by default. |

For an openrouter pricing comparison, sort by `pricing-low-to-high` and add the `providers` extra. Sort by `coding-high-to-low` to compare llm models for coding.

```json
{
  "urls": [],
  "search": "",
  "sort": "pricing-low-to-high",
  "maxItems": 2,
  "extraData": ["providers"],
  "proxyConfiguration": { "useApifyProxy": false }
}
```

> 💡 Start with a small `maxItems` such as 10 to check the result, then raise it.

### ⬆️ Output

The scraped models appear as a dataset in the **Storage** tab. The table view does not show all fields, so export the dataset or open it through the API for the full rows. The overview, pricing, capabilities and performance views give quick tables, and the `providers`, `daily_usage`, `top_apps`, `benchmarks`, `rankings` and `uptime` tables are saved next to the default dataset. The pricing view works as an openrouter models pricing list. Export the dataset as an openrouter models list json file when a script needs it.

The sample below is an abbreviated illustration with made-up names and numbers, matching the input above. Your run returns real catalog data.

```json
[
  {
    "id": "example-lab/example-mini",
    "name": "Example Lab: Example Mini",
    "author": "example-lab",
    "url": "https://openrouter.ai/example-lab/example-mini",
    "status": "ok",
    "context_length": 128000,
    "is_free": false,
    "pricing": {
      "input_per_m_tokens": 0.1,
      "output_per_m_tokens": 0.4,
      "blended_3_to_1_per_m_tokens": 0.175
    },
    "rank_by_weekly_tokens": 12,
    "provider_count": 1,
    "providers": [
      {
        "provider": "Example Host",
        "status": "ok",
        "quantization": "fp8",
        "pricing": { "input_per_m_tokens": 0.1, "output_per_m_tokens": 0.4 },
        "latency_ms": { "p50": 450 },
        "throughput_tps": { "p50": 120 },
        "uptime_today_pct": 99.9
      }
    ]
  },
  {
    "id": "example-lab/example-large",
    "name": "Example Lab: Example Large",
    "author": "example-lab",
    "url": "https://openrouter.ai/example-lab/example-large",
    "status": "ok",
    "context_length": 200000,
    "is_free": false,
    "pricing": {
      "input_per_m_tokens": 0.5,
      "output_per_m_tokens": 2.0,
      "blended_3_to_1_per_m_tokens": 0.875
    },
    "rank_by_weekly_tokens": 4,
    "provider_count": 1,
    "providers": [
      {
        "provider": "Example Host",
        "status": "ok",
        "quantization": "bf16",
        "pricing": { "input_per_m_tokens": 0.5, "output_per_m_tokens": 2.0 },
        "latency_ms": { "p50": 800 },
        "throughput_tps": { "p50": 60 },
        "uptime_today_pct": 99.5
      }
    ]
  }
]
```

A run also saves a `RUN_SUMMARY` record in the key-value store. It lists `modelsSaved`, `modelsCharged`, `inputsNotFound`, `requests`, `spendLimitReached` and `notes`.

### ⚠️ Limitations and error handling

- The Actor reads public data only. It does not read your own OpenRouter account, spend or private data.
- A run returns the current catalog. It does not store price history, so use scheduled runs to build one.
- A field the site does not publish stays `null`. Routers have no provider endpoint, so their provider fields are empty.
- The `providers`, `uptime`, `usage`, `apps` and `benchmarks` extras are loaded per model, which makes the run slower.
- The limit in `maxItems` applies to each entry in `urls`. With an empty list it applies to the whole catalog.
- Failed requests are retried and switched to another connection. If ten requests in a row never reach the site, the run stops and keeps everything saved so far.
- If the full model list is temporarily unavailable, the Actor uses a shorter list. Usage, rankings, benchmarks and provider statistics are then empty, extras are skipped, and `RUN_SUMMARY.notes` says so.
- Prices are those listed on OpenRouter. Use them for an ai model api pricing comparison there, not as the price lists of the model makers.
- An unknown `sort` value falls back to `top-weekly` with a warning in the log.

An input that matches no model is saved as a row with `id` and `error`. It is not billed.

```json
{
  "id": "unknown-author",
  "error": "model or author not found on openrouter.ai"
}
```

If an extra could not be loaded for a model, the row gets an `errors` list such as `["providers: temporarily unavailable"]`.

| Message or status | What it means | What to do |
|---|---|---|
| `Spend limit reached` (run status) | Your spend limit was reached and the run stopped cleanly. | Raise the spend limit and run again. |
| `openrouter.ai could not be reached (blocked or changed). Try again later.` | Nothing was collected and the run failed. | Start the run again later, or set your own proxy. |
| `No models were saved - check the models, search and sort inputs.` | The run finished without a saved model. | Check ids, authors, the search keyword and the sort order. |
| `status` value `router`, `no_endpoint`, `disabled`, `deranked` or `status_<code>` | Routers have no provider endpoint; the others describe the state reported for a model's top provider. | Filter the dataset on `status` if you only want `ok` rows. |

### 🔌 Integrating OpenRouter Models Scraper with other apps

Run OpenRouter Models Scraper from the Apify API, and send the dataset to your tools with [Apify integrations](https://docs.apify.com/integrations). Use [Make](https://docs.apify.com/integrations/make), [Zapier](https://docs.apify.com/integrations/zapier) or [webhooks](https://docs.apify.com/integrations/webhooks) to pass a finished run to a spreadsheet, a database or a chat message. A sheet fed by a schedule can drive a recurring llm pricing comparison.

```bash
curl -X POST "https://api.apify.com/v2/actors/data_wiki~openrouter-models-scraper/runs" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" -H "Content-Type: application/json" \
  -d '{"urls": ["anthropic"], "maxItems": 10, "extraData": ["providers"]}'
```

See the [Apify API reference](https://docs.apify.com/api/v2) for the other calls.

To follow prices over time, create a [schedule](https://docs.apify.com/actors/running/schedules) and compare the datasets of different runs. AI agents can find and run this Actor through the [Apify MCP server](https://docs.apify.com/mcp).

### 🔗 Other scrapers by data_wiki

The Actors below come from the same developer and cover other topics, such as shops, travel and reviews. They are not about AI models, so use them only if you also work with that kind of data.

| Actor | What it extracts | When to use it |
|---|---|---|
| [1688 wholesale products scraper](https://apify.com/data_wiki/1688-wholesale-products-scraper) | Wholesale products from 1688.com by keyword or link, with bulk prices | You compare supplier prices for goods |
| [TikTok Shop search scraper](https://apify.com/data_wiki/tiktok-shop-search-scraper) | TikTok Shop products by keyword with units sold, prices, discounts and reviews | You track product prices and discounts on TikTok Shop |
| [Tripadvisor review scraper](https://apify.com/data_wiki/tripadvisor-review-scraper) | Reviews of hotels, restaurants and attractions with stars, text and trip type | You need review text for analysis |
| [Airbnb listings scraper](https://apify.com/data_wiki/airbnb-scraper) | Airbnb listings by city, search link or listing link, with nightly and stay prices | You compare stay prices in a city |

For shop prices and discounts, see [product prices on TikTok Shop](https://apify.com/data_wiki/tiktok-shop-search-scraper). For travel data, [stay prices from Airbnb](https://apify.com/data_wiki/airbnb-scraper) and [travel review text for AI analysis](https://apify.com/data_wiki/tripadvisor-review-scraper) follow the same pattern of public data in a clean table. [Wholesale price data from 1688](https://apify.com/data_wiki/1688-wholesale-products-scraper) covers goods instead of models.

### ⚖️ Is it legal to scrape OpenRouter?

OpenRouter Models Scraper only reads public pages that any visitor can open, and it does not read private data or account data. You are responsible for following the terms of openrouter.ai and the laws that apply to you. The model data is about products and does not name people. Read Apify's guides on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) and [ethical web scraping](https://blog.apify.com/what-is-ethical-web-scraping-and-how-do-you-do-it/), and ask a lawyer if you are unsure.

### ❓ FAQ

#### Do I need an API key to use OpenRouter Models Scraper?

No. The Actor reads public pages, so it needs no OpenRouter API key, account or login. You only need an Apify account to run it.

#### How many models are there?

The count changes as models are added and retired, and it is in the hundreds. Set `maxItems` to `0` and leave `urls` empty to get the whole catalog. The openrouter ai models list also contains several variants of the same model.

#### How much does it cost?

You pay per saved model: $1.00 per 1,000 on the Free tier, down to $0.70 per 1,000 on the Gold tier and above, plus a start event of $0.00005. See the cost section above for the full table.

#### Can I list only free models?

Yes. Run the Actor, then filter the dataset on `is_free`. That gives an openrouter free models list of every model with no per-token price.

#### Which models cost nothing to call?

The `is_free` field marks openrouter models free of per-token charges. Check `pricing` and the `providers` table to see the exact prices of the others.

#### Why are some fields empty?

A field stays `null` when the site does not publish it for that model. Routers have no provider endpoint, and extras you did not choose are not in the row.

#### What do the price fields contain?

They hold llm api pricing per million tokens for input and output, plus cache, reasoning, audio, image and web search prices when listed. The `effective_pricing` field adds weighted prices for models with the `providers` extra.

#### How do I compare prices across providers?

Add the `providers` extra and use the `providers` table. It has one row per provider, which is the shape an llm api pricing comparison needs.

#### Can I export the rankings?

Yes. The fields `rank_by_weekly_tokens` and `category_rankings` hold the rank data, so you can export openrouter model rankings as a table.

#### Can I run it for one author?

Yes. Put the author name, for example `anthropic`, in `urls`. Use `maxItems` to limit the models for that author, which gives an openrouter llm models list for one author.

#### Do I need proxies?

No. No proxy is used by default. You can set your own proxy in the input if you want one.

#### Can I use OpenRouter Models Scraper through an MCP server?

Yes. AI agents can find and run Apify Actors through the [Apify MCP server](https://docs.apify.com/mcp), then read the dataset of the run.

#### Can I track a model catalog over time?

Yes, with scheduled runs. Each run saves the current catalog, so keep the datasets you want to compare.

### 💬 Your feedback

Found a bug or missing data? Open an issue from the Actor page in Apify Console and include the run link. Need a custom solution? Contact hello.datawiki@gmail.com.

# Actor input Schema

## `urls` (type: `array`):

Model ids (openai/gpt-4o-mini), model page links (https://openrouter.ai/anthropic/claude-sonnet-5.5) or author names (anthropic, google/\*). Bulk input is supported. Leave empty to scrape the whole catalog.

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

Same search box as on openrouter.ai/models, for example llama, vision or deepseek. Leave empty for no filter.

## `sort` (type: `string`):

Order of the models, as on openrouter.ai. Also decides which models are kept when you set a limit.

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

Models to save for EACH model, author or link in the list (3 authors with 20 give up to 60 models; with an empty list it is the limit for the whole catalog). 0 means all (about 700 live variants).

## `extraData` (type: `array`):

Extra details added to every model. Each one makes the run slower; leave empty for catalog fields only.

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

No proxy is used by default. If openrouter.ai rejects requests, the actor switches to stronger proxies automatically.

## Actor input object example

```json
{
  "urls": [
    "openai/gpt-4o-mini",
    "anthropic"
  ],
  "sort": "top-weekly",
  "maxItems": 10,
  "extraData": [
    "providers",
    "uptime",
    "usage",
    "apps",
    "benchmarks"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per model variant with every field.

## `pricing` (type: `string`):

Prices per million tokens for every model.

## `capabilities` (type: `string`):

Tools, reasoning, web search and input types per model.

## `performance` (type: `string`):

Top provider speed and weekly usage per model.

## `providers` (type: `string`):

One row per provider endpoint of each model.

## `daily_usage` (type: `string`):

One row per model per day for the last 30 days.

## `top_apps` (type: `string`):

Top public apps using each model.

## `benchmarks` (type: `string`):

Benchmark scores per provider.

## `rankings` (type: `string`):

Rank and share per usage category.

## `uptime` (type: `string`):

Hourly uptime and availability for the last 3 days.

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

Counts for this run.

# 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 = {
    "urls": [
        "openai/gpt-4o-mini",
        "anthropic"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_wiki/openrouter-models-scraper").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 = {
    "urls": [
        "openai/gpt-4o-mini",
        "anthropic",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("data_wiki/openrouter-models-scraper").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 '{
  "urls": [
    "openai/gpt-4o-mini",
    "anthropic"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call data_wiki/openrouter-models-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,data_wiki/openrouter-models-scraper"
        }
    }
}
```

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/mVGwjK2GG6eSbpJri/builds/sW0mdn06nOQHJut1u/openapi.json