# Vercel AI Gateway Model Catalog Scraper (`rainminer/vercel-ai-gateway-models-scraper`) Actor

Extract public Vercel AI Gateway models: IDs, display names, providers, types, context windows, per-million-token prices, capability tags, and catalog URLs. Filter by provider or type. No login. Export JSON, CSV, or Excel and schedule daily LLM price checks on Apify.

- **URL**: https://apify.com/rainminer/vercel-ai-gateway-models-scraper.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 model record scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## Vercel AI Gateway Model Catalog Scraper

[![Browse Vercel AI Gateway models](https://vercel.com/api/model-og?name=Browse+Models)](https://vercel.com/ai-gateway/models)

**Vercel AI Gateway Model Catalog Scraper** extracts the public [Vercel AI Gateway models catalog](https://vercel.com/ai-gateway/models) into a structured dataset. Paste the catalog URL (or a single model page) and export **model IDs, providers, types, context windows, per-million-token prices, capability tags, and catalog links** — without writing any code.

Run it on the **Apify platform** to schedule daily catalog snapshots, export JSON/CSV/Excel, monitor price changes, and push results into your LLM router or spreadsheet via API.

### What can Vercel AI Gateway Model Catalog Scraper do?

- **Full catalog export** — Pull every public model listed on Vercel AI Gateway in one run.
- **Single-model lookup** — Start from a model page such as `https://vercel.com/ai-gateway/models/gpt-6-luna`.
- **Price comparison** — Get input, output, and cache prices normalized to USD per million tokens.
- **Capability tags** — Keep reasoning, vision, tool-use, structured-output, and other tags as arrays.
- **Provider and type filters** — Limit results to OpenAI, Anthropic, Google, Alibaba, or to language / image / video models.
- **Model cards** — Each row includes a generated catalog image URL for Apify dataset thumbnails.
- **No login** — Only public catalog data. No Vercel account or API key is required.
- **Apify platform** — Schedule crawls, set webhooks, and download JSON, CSV, Excel, or HTML.

### Why scrape Vercel AI Gateway models?

- **LLM routing** — Keep an up-to-date table of model IDs and prices for cost-aware routing.
- **Procurement dashboards** — Compare providers and context windows before you lock a stack.
- **Competitive intelligence** — Track which labs and models Vercel lists, and when prices move.
- **Product catalogs** — Feed playgrounds, comparison pages, and internal wiki tables from a dataset.
- **Video and image pricing** — Capture duration-based video prices alongside token-priced chat models.
- **Capability filtering** — Find models that support vision, tool use, or structured output.
- **Change monitoring** — Schedule daily runs and diff datasets when new models appear.
- **Finance reporting** — Convert published token rates into per-million figures for cost models.
- **Developer docs** — Generate snippets that list current `ownedBy`, `type`, and `contextWindow` values.
- **No-code research** — Analysts can export CSV without calling provider APIs themselves.

### How to use Vercel AI Gateway Model Catalog Scraper

1. Open the Actor in Apify Console.
2. Keep the default **Start URL** `https://vercel.com/ai-gateway/models`, or add a model page URL.
3. Optionally set **Provider** (`openai`), **Model type** (`language`), or a **Capability tag** (`reasoning`).
4. Set **Maximum items** (models per start URL). Use a small number for tests, or a large number for a full dump.
5. Run the Actor and download the dataset as JSON, CSV, Excel, or HTML.

### Input

Vercel AI Gateway Model Catalog Scraper accepts **Start URLs**, **maxItems** (per start URL), optional **model type / provider / tag** filters, and optional **proxy configuration**. See the **Input** tab in Apify Console for details.

Supported start URLs:

- Catalog: `https://vercel.com/ai-gateway/models`
- Gateway home: `https://vercel.com/ai-gateway`
- Model pages: `https://vercel.com/ai-gateway/models/gpt-6-luna`

### Output

Each result is one catalog model. You can download the dataset in **JSON, CSV, Excel, or HTML**.

```json
{
  "id": "openai/gpt-6-luna",
  "name": "GPT-6 Luna",
  "imageUrl": "https://vercel.com/api/model-og?name=GPT-6+Luna&subtitle=openai%2Fgpt-6-luna",
  "url": "https://vercel.com/ai-gateway/models/gpt-6-luna",
  "ownedBy": "openai",
  "type": "language",
  "description": "GPT-6 Luna is OpenAI's efficient reasoning model for focused, high-volume tasks.",
  "contextWindow": 1050000,
  "maxTokens": 128000,
  "inputPricePerMillion": 0.1,
  "outputPricePerMillion": 0.5,
  "cacheReadPricePerMillion": 0.01,
  "cacheWritePricePerMillion": 0.125,
  "webSearchPrice": 10,
  "variesByProvider": false,
  "videoDurationPricing": [],
  "tags": ["reasoning", "tool-use", "vision"],
  "inputModalities": ["text", "image", "pdf"],
  "outputModalities": ["text"],
  "supportedParameters": ["max_tokens", "temperature", "tools"],
  "knowledgeCutoff": null,
  "zdr": "none",
  "noTraining": "all",
  "regions": ["us"],
  "releasedAt": "2026-09-22T00:00:00.000Z",
  "createdAt": "2025-08-21T00:00:00.000Z",
  "deprecatedAt": null,
  "scrapedAt": "2026-09-22T19:00:00.000Z"
}
```

### What data can you extract from Vercel AI Gateway?

| Field | Description |
| --- | --- |
| id | Gateway model ID (`provider/slug`) |
| name | Display name |
| imageUrl | Catalog card image |
| url | Public model page on vercel.com |
| ownedBy | Provider that owns the model |
| type | language, image, video, embedding, and similar |
| description | Public catalog description when present |
| contextWindow | Context window in tokens |
| maxTokens | Max output tokens when listed |
| inputPricePerMillion | Input price in USD per 1M tokens |
| outputPricePerMillion | Output price in USD per 1M tokens |
| cacheReadPricePerMillion | Prompt-cache read price per 1M tokens |
| cacheWritePricePerMillion | Prompt-cache write price per 1M tokens |
| webSearchPrice | Web-search add-on price when listed |
| variesByProvider | True when token prices vary by downstream provider |
| videoDurationPricing | Resolution and USD-per-second rates for video models |
| tags | Capability tags |
| inputModalities / outputModalities | Accepted and produced modalities |
| knowledgeCutoff | Knowledge cutoff string when listed |
| zdr / noTraining | Zero-data-retention and training policy flags |
| releasedAt / deprecatedAt | Release and deprecation timestamps when listed |
| scrapedAt | ISO timestamp when the row was saved |

### How much does it cost to scrape Vercel AI Gateway models?

This Actor uses a lightweight **HTTP crawler (no browser)** and **no proxy by default**, so compute usage stays low. A test run of a few models usually finishes in under a minute on the Apify free tier. Larger exports scale with the number of models you save.

Pay-per-event pricing charges one **result-item** per model. Platform usage is included in that price (pure PPE).

| Event | FREE tier | GOLD tier |
| --- | --- | --- |
| Actor start | **$0.00005** | **$0.00005** |
| Model record scraped | **$1.99 / 1,000** | **$1.49 / 1,000** |

### Tips and advanced options

- Start from `https://vercel.com/ai-gateway/models` to snapshot the full public catalog.
- Raise **maxItems** above the catalog size (several hundred models) when you want every row.
- Use **provider** + **model type** together, for example `google` and `language`.
- For one model, paste its catalog page instead of the list URL.

### FAQ, disclaimers, and support

**Is it legal to scrape Vercel AI Gateway models?**\
This Actor collects only **public catalog information** that Vercel publishes on the models pages. You are responsible for complying with Vercel’s terms and any applicable laws when you store or reuse the data.

**Do I need a Vercel API key?**\
No. The Actor reads the public catalog. It does not call your Vercel project, billing, or private logs.

**Why are some prices null?**\
Image and video models often use duration or generation pricing instead of token rates. Those rows still include `videoDurationPricing` or other listed fields.

**Something not working?**\
Use the **Issues** tab to report bugs or request features.

### Image Credit

Image credit: [vercel.com](https://www.vercel.com/)

# Actor input Schema

## `startUrls` (type: `array`):

Vercel AI Gateway catalog or model pages. Use https://vercel.com/ai-gateway/models for the full catalog, or a model page such as https://vercel.com/ai-gateway/models/gpt-6-luna.

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

Maximum number of models to return per start URL.

## `modelType` (type: `string`):

Optional filter by catalog type (language, image, video, embedding, and so on). Leave empty to include every type.

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

Optional provider filter matching owned\_by, e.g. openai, anthropic, google, alibaba.

## `tag` (type: `string`):

Optional capability tag filter, e.g. reasoning, vision, tool-use, structured-output.

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

Proxy settings. The public catalog works without a proxy in most regions.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://vercel.com/ai-gateway/models"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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 = {
    "startUrls": [
        {
            "url": "https://vercel.com/ai-gateway/models"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/vercel-ai-gateway-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 = {
    "startUrls": [{ "url": "https://vercel.com/ai-gateway/models" }],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/vercel-ai-gateway-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 '{
  "startUrls": [
    {
      "url": "https://vercel.com/ai-gateway/models"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rainminer/vercel-ai-gateway-models-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/vercel-ai-gateway-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/rEMHvwZNqevdbYZig/builds/BMI1Dnicc7il9aVbk/openapi.json