# BridgeBench Rankings Scraper (`axiomworks/bridgebench-leaderboard-scraper`) Actor

Turn the BridgeBench coding leaderboard into a dataset of ranked models with overall and nine axis scores, displayed and blended prices, and context. Matching uses model IDs, names or dated snapshots—not fuzzy guesses—and adds OpenRouter details, provider uptime and a routing config with fallbacks.

- **URL**: https://apify.com/axiomworks/bridgebench-leaderboard-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.79 / 1,000 results

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

**Returns:** one row per AI model on the BridgeBench leaderboard with `rank`, `modelName`, `vendor`, `overallScore`, `bridgebenchPrice`, `openrouterId`, `providers` and `routingConfig`.
**Input:** `{"startUrls": [{"url": "https://www.bridgebench.ai/leaderboard"}], "maxItems": 10}`
**Best for:** choosing a coding model by score and price, building OpenRouter routing and fallback configs, and tracking leaderboard changes over time.

```json
{
    "rank": 1,
    "modelName": "Claude Opus 5.5",
    "vendor": "Anthropic",
    "overallScore": 760,
    "blendedPricePer1M": 8,
    "openrouterId": "anthropic/claude-opus-5.5",
    "providerCount": 11,
    "scorePerDollar": 95
}
```

### What does BridgeBench Rankings Scraper do?

BridgeBench Rankings Scraper reads the public BridgeBench AI coding leaderboard and returns one dataset row per model. Each row has the overall BridgeBench score, the nine axis scores (reasoning, frontend, backend, one-shot, security, trustworthiness, efficiency, speed and cost), the price BridgeBench shows, the blended price per 1M tokens, the context window and the model's rank. It works like a BridgeBench API: you get the leaderboard as clean JSON instead of a web page, with no login.

Each BridgeBench model is then matched to the same model on OpenRouter, using OpenRouter's public model list. Matched rows get live OpenRouter prices (input, output and cached input per 1M tokens), the context length, the maximum output tokens, input modalities, tool support, and the list of OpenRouter provider endpoints with their own prices, quantization and uptime over the last 30 minutes. The match is strict (same id, same name, or a dated snapshot of the same id). A model that isn't on OpenRouter keeps its BridgeBench data and has its OpenRouter fields set to null, so a wrong match never puts the wrong prices on a model.

Finally, every matched row gets a `routingConfig`: a ready-to-paste fragment for an OpenRouter chat completion request with the model, fallback models taken from the next-ranked BridgeBench models, and a provider order built from the healthiest endpoints. It's the "leaderboard plus routing config" view as data.

### What data can you get from BridgeBench?

| Field | Description | Example |
|---|---|---|
| `id` | BridgeBench model id, unique per run | `anthropic/claude-opus-5.5` |
| `rank` | Position on the leaderboard by overall score (1 = best) | `1` |
| `modelName` | Model name as shown on BridgeBench | `Claude Opus 5.5` |
| `vendor` | Model vendor | `Anthropic` |
| `bridgebenchId` | Model id used by BridgeBench | `anthropic/claude-opus-5.5` |
| `provisional` | True when BridgeBench marks the scores as provisional | `false` |
| `overallScore` | Overall BridgeBench score (0-1000) | `760` |
| `reasoningScore` | Reasoning score | `920` |
| `frontendScore` | Frontend coding score | `950` |
| `backendScore` | Backend coding score | `900` |
| `oneShotScore` | One-shot score | `830` |
| `securityScore` | Security score | `650` |
| `trustScore` | Trustworthiness score | `900` |
| `efficiencyScore` | Efficiency score | `870` |
| `speedScore` | Speed score | `380` |
| `costScore` | Cost score (higher means cheaper) | `440` |
| `bridgebenchPrice` | Input / output price per 1M tokens, as text exactly as shown on BridgeBench | input / output text |
| `blendedPricePer1M` | BridgeBench blended price, USD per 1M tokens | `8` |
| `contextLabel` | Context window as shown | `1M` |
| `contextTokens` | Context window in tokens | `1000000` |
| `detailUrl` | The model's BridgeBench page | `https://www.bridgebench.ai/leaderboard/claude-opus-5-5` |
| `pricesCheckedDate` | When BridgeBench last checked its prices | `Sep 29, 2026` |
| `openrouterId` | Matching OpenRouter model id, or null | `anthropic/claude-opus-5.5` |
| `openrouterMatch` | How the match was made: `id`, `name`, `snapshot` or `none` | `id` |
| `openrouterName` | Model name on OpenRouter | `Anthropic: Claude Opus 5.5` |
| `inputPricePer1M` | OpenRouter input price, USD per 1M tokens | `4` |
| `outputPricePer1M` | OpenRouter output price, USD per 1M tokens | `20` |
| `cacheReadPricePer1M` | OpenRouter cached input price, USD per 1M tokens | `0.2` |
| `openrouterContextLength` | Context length on OpenRouter | `1000000` |
| `maxCompletionTokens` | Maximum output tokens of the top provider | `128000` |
| `inputModalities` | Input types the model accepts | `["text","image","file"]` |
| `supportsTools` | True when tool calling is supported | `true` |
| `providerCount` | Number of OpenRouter provider endpoints | `11` |
| `providers` | Provider endpoints: provider, tag, prices, context, quantization, uptime, status | see Output |
| `scorePerDollar` | Overall score divided by blended price per 1M tokens | `95` |
| `routingConfig` | OpenRouter request fragment: model, fallback models, provider order | see Output |
| `scrapedAt` | When the row was collected (ISO 8601) | `2026-10-06T03:29:45.223Z` |
| `sourceUrl` | BridgeBench page the row was read from | `https://www.bridgebench.ai/leaderboard` |

### How to use BridgeBench Rankings Scraper

1. Open the Actor in Apify Console and go to the Input tab.
2. Leave **Leaderboard or model URLs** at `https://www.bridgebench.ai/leaderboard` to get every model, or add model pages such as `https://www.bridgebench.ai/leaderboard/claude-opus-5-5` to get only those models.
3. Optionally narrow the list with **Model name filter** (for example `claude` or `gpt-6`), **Vendor filter** (for example `Anthropic`), **Minimum score** or **Maximum blended price**.
4. Choose **Sort by** to order the rows by any BridgeBench score, or by `scorePerDollar` to find the best value.
5. In **OpenRouter routing**, choose the `provider.sort` value for the routing config, how many fallback models to include, and how many provider endpoints to list per model.
6. Click **Start**. A full run takes well under a minute.
7. Open the Output tab to see the table, or export the dataset as JSON, CSV, Excel, XML or RSS.

Tips:

The leaderboard has 29 models on 13 October 2026, so the default `maxItems` of 50 returns all of them. Set `maxItems` lower for the top N after sorting and filtering. Model and vendor filters intersect. If none match, clear them or lower `minScore`.

Fallback models in `routingConfig` come from the whole leaderboard, not only from the rows you filtered, so a single-model run still gets sensible fallbacks.

BridgeBench usually loads without a proxy. If a load is blocked, the Actor retries on its own through Apify Proxy (datacenter first, then residential), so you normally don't need to change the proxy setting.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | array of URL objects or strings | No | `https://www.bridgebench.ai/leaderboard` for every model, or `/leaderboard/<model>` pages for specific models. A model slug (`claude-opus-5-5`) or BridgeBench id (`anthropic/claude-opus-5.5`) also works. Empty means the whole leaderboard. |
| `models` | array of strings | No | Keep models whose name, id or slug contains any of these terms (case-insensitive). |
| `vendors` | array of strings | No | Keep models from these vendors (exact name, case-insensitive). |
| `sortBy` | string | No | `overall` (default), `reasoning`, `frontend`, `backend`, `oneShot`, `security`, `trustworthiness`, `efficiency`, `speed`, `cost` or `scorePerDollar`. Highest first. |
| `minScore` | integer | No | Minimum score on the `sortBy` axis, 0-1000, default 0. Ignored for `scorePerDollar`. |
| `maxBlendedPricePer1M` | number | No | Drop models with a blended price above this (USD per 1M tokens). |
| `includeProvisional` | boolean | No | Include models with provisional scores. Default true. |
| `onlyOnOpenRouter` | boolean | No | Drop models with no OpenRouter match. Default false. |
| `maxItems` | integer | No | Shared maximum rows across all targets after filtering and sorting, 1-10000, default 50. |
| `includeProviders` | boolean | No | Fetch OpenRouter provider endpoints per model. Default true. |
| `maxProvidersPerModel` | integer | No | Endpoints listed per model, 1-50, default 10. |
| `routingSort` | string | No | `provider.sort` in the routing config: `price` (default), `throughput` or `latency`. |
| `fallbackCount` | integer | No | Fallback models in the routing config, 0-3, default 2. |
| `proxyConfiguration` | object | No | Proxy for the BridgeBench page. Default: no proxy, with automatic Apify Proxy retries. |

Example: Anthropic, OpenAI and Google models with a frontend score of at least 500, sorted by frontend score, only those available on OpenRouter:

```json
{
    "vendors": ["OpenAI", "Anthropic", "Google"],
    "sortBy": "frontend",
    "minScore": 500,
    "onlyOnOpenRouter": true,
    "routingSort": "throughput",
    "fallbackCount": 2,
    "maxItems": 20
}
```

### Output

Historical rows from a run on 6 October 2026, with `maxProvidersPerModel` set to 2 to keep them short (the `bridgebenchPrice` text is left out here). The second model is not on OpenRouter, so its OpenRouter fields are null.

```json
[
    {
        "id": "anthropic/claude-opus-5.5",
        "rank": 1,
        "modelName": "Claude Opus 5.5",
        "vendor": "Anthropic",
        "bridgebenchId": "anthropic/claude-opus-5.5",
        "provisional": false,
        "overallScore": 760,
        "reasoningScore": 920,
        "frontendScore": 950,
        "backendScore": 900,
        "oneShotScore": 830,
        "securityScore": 650,
        "trustScore": 900,
        "efficiencyScore": 870,
        "speedScore": 380,
        "costScore": 440,
        "blendedPricePer1M": 8,
        "contextLabel": "1M",
        "contextTokens": 1000000,
        "detailUrl": "https://www.bridgebench.ai/leaderboard/claude-opus-5-5",
        "pricesCheckedDate": "Sep 29, 2026",
        "openrouterId": "anthropic/claude-opus-5.5",
        "openrouterMatch": "id",
        "openrouterName": "Anthropic: Claude Opus 5.5",
        "inputPricePer1M": 4,
        "outputPricePer1M": 20,
        "cacheReadPricePer1M": 0.2,
        "openrouterContextLength": 1000000,
        "maxCompletionTokens": 128000,
        "inputModalities": ["text", "image", "file"],
        "supportsTools": true,
        "providerCount": 11,
        "providers": [
            {
                "provider": "Azure",
                "tag": "azure/global",
                "inputPricePer1M": 4,
                "outputPricePer1M": 20,
                "contextLength": 1000000,
                "quantization": "unknown",
                "uptimeLast30m": 100,
                "status": 0
            },
            {
                "provider": "Amazon Bedrock",
                "tag": "amazon-bedrock/us-east-1",
                "inputPricePer1M": 4.4,
                "outputPricePer1M": 22,
                "contextLength": 1000000,
                "quantization": "unknown",
                "uptimeLast30m": 100,
                "status": 0
            }
        ],
        "scorePerDollar": 95,
        "routingConfig": {
            "model": "anthropic/claude-opus-5.5",
            "models": ["openai/gpt-6-astra", "anthropic/claude-fable-5.1"],
            "provider": {
                "order": ["azure/global", "amazon-bedrock/us-east-1", "google-vertex/europe"],
                "allow_fallbacks": true,
                "sort": "price"
            }
        },
        "scrapedAt": "2026-10-06T03:29:45.223Z",
        "sourceUrl": "https://www.bridgebench.ai/leaderboard"
    },
    {
        "id": "stepfun/step-5-preview",
        "rank": 11,
        "modelName": "Step 5 Preview",
        "vendor": "StepFun",
        "bridgebenchId": "stepfun/step-5-preview",
        "provisional": false,
        "overallScore": 572,
        "reasoningScore": 680,
        "frontendScore": 550,
        "backendScore": 700,
        "oneShotScore": 600,
        "securityScore": 200,
        "trustScore": 580,
        "efficiencyScore": 630,
        "speedScore": 660,
        "costScore": 550,
        "blendedPricePer1M": 1.425,
        "contextLabel": "1M",
        "contextTokens": 1000000,
        "detailUrl": "https://www.bridgebench.ai/leaderboard/step-5-preview",
        "pricesCheckedDate": "Sep 29, 2026",
        "openrouterId": null,
        "openrouterMatch": "none",
        "openrouterName": null,
        "inputPricePer1M": null,
        "outputPricePer1M": null,
        "cacheReadPricePer1M": null,
        "openrouterContextLength": null,
        "maxCompletionTokens": null,
        "inputModalities": null,
        "supportsTools": null,
        "providerCount": 0,
        "providers": null,
        "scorePerDollar": 401.4,
        "routingConfig": null,
        "scrapedAt": "2026-10-06T03:29:45.223Z",
        "sourceUrl": "https://www.bridgebench.ai/leaderboard"
    }
]
```

The Output tab shows a Leaderboard table with the rank, name, vendor, all scores, BridgeBench price, score per dollar, OpenRouter id and prices, provider count and routing config. You can download the dataset as JSON, CSV, Excel, XML or RSS, or read it through the Apify API.

### How much does it cost to scrape BridgeBench?

BridgeBench Rankings Scraper is charged per result: one result is one model row in the dataset. You pay only for the rows returned, and `maxItems` caps how many that can be. Filters such as `models`, `vendors` and `minScore` also reduce the number of rows, and so the charge. See the Pricing tab for the current price.

### Use with AI agents (MCP)

Connect BridgeBench Rankings Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/bridgebench-leaderboard-scraper"
        }
    }
}
```

Example prompts:

1. "Use the BridgeBench scraper to find the three best frontend coding models among the ten cheapest by blended price, and give me their OpenRouter routing configs."
2. "Get the BridgeBench leaderboard sorted by score per dollar and tell me which models on OpenRouter have the best value for backend work."
3. "Look up Claude Sonnet 5.5 and GPT-6.1 Sol on BridgeBench, compare their scores, and list the OpenRouter providers with the best uptime for each."

### Integrations and API

Run BridgeBench Rankings Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/bridgebench-leaderboard-scraper").call(
    run_input={"startUrls": [{"url": "https://www.bridgebench.ai/leaderboard"}], "sortBy": "scorePerDollar", "maxItems": 10}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rank"], item["modelName"], item["scorePerDollar"], item["routingConfig"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/bridgebench-leaderboard-scraper').call({
    startUrls: [{ url: 'https://www.bridgebench.ai/leaderboard' }],
    vendors: ['Anthropic', 'OpenAI'],
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~bridgebench-leaderboard-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://www.bridgebench.ai/leaderboard"}], "maxItems": 10}'
```

You can also connect the Actor to Make, Zapier, n8n, Google Sheets, Slack or your own webhooks from the Integrations tab.

### FAQ

**How many models does a run return?**
As many as are on the BridgeBench leaderboard and pass your filters, up to `maxItems`. The leaderboard has 29 models on 13 October 2026 at the time of writing.

**How fresh is the data?**
Every run reads the live BridgeBench page and the live OpenRouter API. BridgeBench shows when it last checked its own prices, and that date is in `pricesCheckedDate`. OpenRouter prices and uptime are as of the run, and `scrapedAt` records when that was.

**Why are the OpenRouter fields empty for some models?**
Some BridgeBench models, such as previews or unreleased variants, are not on OpenRouter. The Actor only matches by the same id, the same name, or a dated snapshot of the same id, and never guesses. When there is no match, `openrouterMatch` is `none` and the OpenRouter fields are null. Set `onlyOnOpenRouter` to true to drop these rows.

**Why are BridgeBench and OpenRouter prices different?**
`bridgebenchPrice` and `blendedPricePer1M` are what BridgeBench shows on its page. `inputPricePer1M` and `outputPricePer1M` come from OpenRouter, and each entry in `providers` has that endpoint's own price. They can differ when a provider charges more for a region or a faster tier, or when BridgeBench hasn't rechecked its prices yet.

**How is the routing config built?**
`model` is the matched OpenRouter id. `models` lists up to `fallbackCount` other models that are on OpenRouter, starting with the next-ranked BridgeBench models. `provider.order` lists the tags of up to three healthy endpoints with the best recent uptime, `allow_fallbacks` is true, and `provider.sort` is your `routingSort` choice. It is a suggestion based on the scores and uptime at run time, not a guarantee.

**Why did my run return 0 results?**
Either a filter matched nothing (for example a misspelled vendor or a very high `minScore`), a model URL didn't match any model on the leaderboard, or a start URL was not a bridgebench.ai leaderboard page. The run's status message says which. If BridgeBench was blocked even after the automatic proxy retries, the status message says that too; try again later or set the proxy to Apify Proxy residential.

**Can I get one model only?**
Yes. Put its BridgeBench page in `startUrls`, for example `https://www.bridgebench.ai/leaderboard/gpt-6-astra`, or use the `models` filter with part of its name.

### Is it legal to scrape BridgeBench?

This Actor reads only public pages and public API data: the BridgeBench leaderboard, which anyone can open without an account, and OpenRouter's public model list. It doesn't log in and doesn't collect personal data. BridgeBench's scores and methodology belong to BridgeBench; each row keeps its `sourceUrl` and `detailUrl` so you can credit the source. Check that your use of the data fits your own legal and contractual situation. This Actor is not affiliated with or endorsed by BridgeBench or OpenRouter.

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

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

Select targets as \[{"url":"https://www.bridgebench.ai/leaderboard"}] or strings such as "claude-opus-5-5" or "anthropic/claude-opus-5.5". Empty or omitted selects all models; /leaderboard/<slug> selects one. Both bridgebench.ai hosts work. Foreign URLs and unknown models yield no rows; correct the target. A full leaderboard target selects all models even alongside detail targets.

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

Keep models matching any term in their name, id or slug, case-insensitive; spaces, dots, dashes and underscores are ignored for an additional match. Example: \["claude","gpt"]. Default \[] keeps all models. This filter intersects with vendors and the other filters; empty results mean broaden the terms.

## `vendors` (type: `array`):

Keep models whose vendor equals any supplied name, case-insensitive, e.g. \["Anthropic","OpenAI"]. Default \[] keeps all vendors. This filter intersects with models and other filters; use a vendor from the leaderboard if no rows match.

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

Order models highest first using overall (default), reasoning, frontend, backend, oneShot, security, trustworthiness, efficiency, speed, cost or scorePerDollar. Example: "frontend". rank always remains the overall leaderboard position; minScore applies to the selected score axis except scorePerDollar.

## `minScore` (type: `integer`):

Keep models scoring at least this on sortBy, 0-1000, default 0. Example: 500 with sortBy="frontend". Ignored for scorePerDollar. Lower this threshold if no rows match.

## `maxBlendedPricePer1M` (type: `number`):

Keep models with BridgeBench blendedPricePer1M at or below this number, e.g. 5. Omitted means no cap. With a cap, models missing a blended value are excluded. Increase or remove the cap if no rows match.

## `includeProvisional` (type: `boolean`):

Include models marked provisional when true (default); false excludes them. Example: false. Other filters still apply.

## `onlyOnOpenRouter` (type: `boolean`):

Return only models matched on OpenRouter when true, e.g. true. Default false retains unmatched BridgeBench rows with null OpenRouter fields. If the OpenRouter model list is unavailable, true can yield no rows; use false to retain BridgeBench data.

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

Return at most this many distinct models across all startUrls combined, after filters and sorting; 1-10000, default 50, prefill 10. Example: 1. Fewer rows return when fewer models match. Only returned results are charged.

## `includeProviders` (type: `boolean`):

Fetch endpoint details for matched OpenRouter models when true (default), e.g. false to skip these requests. False leaves providers null, providerCount 0 and routingConfig.provider.order empty; model pricing and fallback routing remain available.

## `maxProvidersPerModel` (type: `integer`):

Keep up to this many provider entries per model, 1-50, default 10, e.g. 2. Used only when includeProviders=true. Healthy endpoints come first, then highest uptime. providerCount reports the full endpoint count; routing order uses up to three healthy endpoints from that full list.

## `routingSort` (type: `string`):

Set routingConfig.provider.sort to price (default), throughput or latency, e.g. "throughput". This changes the routing request fragment, not dataset ordering; use sortBy for output order.

## `fallbackCount` (type: `integer`):

Put up to this many other matched models in routingConfig.models, 0-3, default 2, e.g. 0 for none. Uses the whole leaderboard even when output is filtered: next-lower overall ranks first, then higher ranks. Unmatched models have no routing config.

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

Set browser proxy options, e.g. {"useApifyProxy":false} (default). Failed loads retry with fresh sessions through Apify Proxy, datacenter then residential when available on Apify. OpenRouter requests go direct. If blocked after retries, the run returns no rows; retry later or select an available proxy.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.bridgebench.ai/leaderboard"
    }
  ],
  "models": [],
  "vendors": [],
  "sortBy": "overall",
  "minScore": 0,
  "includeProvisional": true,
  "onlyOnOpenRouter": false,
  "maxItems": 10,
  "includeProviders": true,
  "maxProvidersPerModel": 10,
  "routingSort": "price",
  "fallbackCount": 2,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

Dataset with one item per model: BridgeBench scores, OpenRouter prices, providers and routing config.

# 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://www.bridgebench.ai/leaderboard"
        }
    ],
    "models": [],
    "sortBy": "overall",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/bridgebench-leaderboard-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://www.bridgebench.ai/leaderboard" }],
    "models": [],
    "sortBy": "overall",
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/bridgebench-leaderboard-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://www.bridgebench.ai/leaderboard"
    }
  ],
  "models": [],
  "sortBy": "overall",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/bridgebench-leaderboard-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,axiomworks/bridgebench-leaderboard-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/T5d3hK4ghhVWcsfCR/builds/av5lW8aRGYZbqiyUs/openapi.json