# OpenRouter Models Tracker (`cynix_dev/openrouter-models-tracker`) Actor

Indexes the live OpenRouter model catalog into RAG-ready records with pricing, context, and capability flags. Detects new models and price changes between runs. Keyless, no proxy.

- **URL**: https://apify.com/cynix\_dev/openrouter-models-tracker.md
- **Developed by:** [Cynix Dev](https://apify.com/cynix_dev) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / actor start

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?

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

## OpenRouter Models Tracker

The only Apify actor that turns OpenRouter's **keyless public model API** into a clean, diffable model-intelligence feed. It snapshots the entire live catalog (422+ models) into RAG-ready records — per-token pricing, context length, architecture, modality, reasoning support, knowledge cutoff — and tells you what changed since the last run: new models, removals, and price moves.

### What it does

1. **Indexes** every model into records: `model_id`, `name`, `context_length`, `prompt_price_per_mtok`, `completion_price_per_mtok`, `architecture`, `modality`, `reasoning`, `knowledge_cutoff`, `provider`, `capabilities`.
2. **Filters** optionally by capability (`reasoning`, `vision`, `function_calling`, `json_mode`, `web_search`, `audio`, `video`), minimum context length, or max price.
3. **Detects change** (on by default) — stores a snapshot in actor KV and emits `change` records for NEW / REMOVED / PRICE DROP / PRICE RISE models versus the previous run. The first run establishes the baseline and emits no changes.

### Input example

```json
{
  "onlyCapabilities": ["reasoning"],
  "minContextLength": 200000,
  "maxPricePerMTok": 2,
  "changeMonitor": true
}
```

### Output example (model record)

```json
{
  "kind": "model",
  "model_id": "deepseek/deepseek-v4-flash-vision",
  "name": "DeepSeek: DeepSeek V4 Flash Vision",
  "description": "A fast vision-capable reasoning model from DeepSeek.",
  "context_length": 1048576,
  "prompt_price_per_mtok": 0.22,
  "completion_price_per_mtok": 0.48,
  "architecture": "deepseek",
  "modality": "text,image",
  "reasoning": true,
  "knowledge_cutoff": "2025-12",
  "provider": "DeepSeek",
  "capabilities": ["reasoning", "function_calling", "json_mode", "vision"]
}
```

Output example (change record, from a later run where a model repriced):

```json
{
  "kind": "change",
  "model_id": "openai/gpt-5.5-mini",
  "name": "OpenAI: GPT-5.5 Mini",
  "description": "PRICE DROP: prompt $1.20/MTok -> $0.90/MTok",
  "change": "PRICE DROP"
}
```

A real run with the filter above returned **195** reasoning models at ≥200k context under $2/MTok. A second run with the catalog unchanged returned 422 models and **zero** change records — the delta logic does not emit false positives.

### How to use

1. Open the Actor and paste the JSON input (or use the form fields).
2. Set `onlyCapabilities` / `minContextLength` / `maxPricePerMTok` to narrow the catalog, or leave empty for everything.
3. Keep `changeMonitor` on and schedule the Actor (e.g. daily) to build a model-market watch.
4. Click **Start**. Records appear in the default dataset.

### Source notes

OpenRouter's public API (`openrouter.ai/api/v1/models`) does **not** expose modality flags for most models, so `vision` / `audio` capability is derived from the model description text. Pricing is normalized to USD per million tokens.

### Pricing

Pay-per-event: a small per-run start fee plus a per-record item fee. Source is public keyless JSON — no proxy, no per-call API cost. See the Actor's pricing tab for the current rate.

### Compliance

Reads only publicly published model metadata from OpenRouter's open API. No personal data, no login, no platform ToS conflict.

### Support

Found a bug or need a field added? Open an issue on the Actor's Issues tab.

# Actor input Schema

## `onlyCapabilities` (type: `array`):

Optional capability filter. One or more of: reasoning, vision, function\_calling, json\_mode, web\_search, audio, video. Leave empty to index all models.

## `minContextLength` (type: `integer`):

Only include models with context\_length >= this value. 0 = no filter.

## `maxPricePerMTok` (type: `number`):

Only include models with prompt price <= this USD per million tokens. 0 = no filter.

## `changeMonitor` (type: `boolean`):

Compare this run against the previous run (stored in actor KV) and emit change records: new models, removed models, and price changes. Requires a prior run with this enabled.

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

Proxy configuration. Not required for this actor's keyless sources; left for parity.

## Actor input object example

```json
{
  "onlyCapabilities": [
    "tools",
    "reasoning"
  ],
  "minContextLength": 0,
  "maxPricePerMTok": 0,
  "changeMonitor": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `kind` (type: `string`):

Either 'model' for a catalog entry or 'change' for a change-detection record.

## `model_id` (type: `string`):

OpenRouter model identifier, e.g. 'anthropic/claude-3.5-sonnet'.

## `name` (type: `string`):

Human-readable model name.

## `description` (type: `string`):

Model description from OpenRouter.

## `context_length` (type: `string`):

Maximum context window in tokens.

## `prompt_price_per_mtok` (type: `string`):

Prompt price in USD per million tokens.

## `completion_price_per_mtok` (type: `string`):

Completion price in USD per million tokens.

## `architecture` (type: `string`):

Tokenizer / architecture family, e.g. 'claude'.

## `modality` (type: `string`):

Input/output modality, e.g. 'text+image->text'.

## `reasoning` (type: `string`):

Whether the model exposes a reasoning/chain-of-thought mode.

## `knowledge_cutoff` (type: `string`):

Training data cutoff, when known.

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

Owning provider, e.g. 'Anthropic'.

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

Capability flags such as reasoning, vision, function\_calling, web\_search.

## `change` (type: `string`):

For change records: 'new', 'removed', or a price-delta description.

## `fetched_at` (type: `string`):

ISO-8601 timestamp of the crawl.

# 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 = {
    "onlyCapabilities": [
        "tools",
        "reasoning"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("cynix_dev/openrouter-models-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 = {
    "onlyCapabilities": [
        "tools",
        "reasoning",
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("cynix_dev/openrouter-models-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 '{
  "onlyCapabilities": [
    "tools",
    "reasoning"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call cynix_dev/openrouter-models-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cynix_dev/openrouter-models-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/DabGU2n8nlpmCYRRH/builds/PTX2FYf02FdffNLzy/openapi.json