# Anthropic Pricing Scraper (`axiomworks/anthropic-pricing-scraper`) Actor

Scrape public Claude documentation and pricing pages for structured API model and subscription plan records. Results include model names, API IDs, lifecycle states, token pricing fields, and plan details. Models with prompt-length pricing are returned as separate rows for each tier.

- **URL**: https://apify.com/axiomworks/anthropic-pricing-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 $2.98 / 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 Claude API model price row or Claude plan with `name`, `inputPerMTok`, `outputPerMTok`, `cacheReadPerMTok`, `batchInputPerMTok`, `apiModelId`, `deprecationState`, `monthlyPriceUsd`.
**Input:** `{"startUrls": [{"url": "https://platform.claude.com/docs/en/about-claude/pricing"}], "recordTypes": ["api_model"], "maxItems": 50}`
**Best for:** tracking Anthropic API price changes, comparing Claude model costs in a spreadsheet, feeding current Claude plan prices into dashboards or AI agents.

```json
{
    "recordType": "api_model",
    "name": "Claude Opus 4.5",
    "family": "Opus",
    "version": "4.5",
    "inputPerMTok": 5,
    "outputPerMTok": 25,
    "apiModelId": "claude-opus-4-5-20251101",
    "deprecationState": "Active"
}
```

### What does Anthropic Pricing Scraper do?

Anthropic Pricing Scraper is an Anthropic pricing scraper and Claude pricing API in one Actor. It reads the public Claude pricing pages and returns structured rows: one row per model price row from the Claude API documentation, and one row per subscription plan or seat from the Claude pricing page. It needs no login and no API key from Anthropic.

For API models you get the input price, output price, 5 minute and 1 hour cache write prices, cache read price, batch processing prices, fast mode prices and the tool use system prompt token counts, all as plain numbers per million tokens. Each model is also matched with its API model ID and lifecycle state (Active, Deprecated or Retired) from the Anthropic model deprecations page, so you can see at a glance which models are still sold. Models that are priced by prompt length, such as Claude Haiku 5.5, produce one row per prompt length tier.

For plans you get Free, Pro, Max, the Team standard and premium seats and Enterprise, with the displayed price text, the monthly price, the annual price per month, the annual total, the feature list and the sign-up link.

The Actor reads the documentation page as markdown, which is one small file, so a normal run takes two requests and finishes in a few seconds. It looks up table columns by their header text instead of by position, so new Claude models and renamed columns are picked up without a code change.

### What data can you get from Anthropic?

Every record has all fields below. Fields that a page does not have are returned as null: plan fields are null on model rows, and batch, fast mode, tool use and API ID fields are null on rows read from the claude.com page. Docs rows come from the Claude API documentation; claude.com rows come from the public pricing page.

| Field | Description | Example |
|---|---|---|
| `id` | Stable record id: model:<name>\[:<prompt length condition>]:<source> or plan:<planKey>. Unique within a run. | model:Claude Opus 4.5:platform_docs |
| `sourceUrl` | The document the record was read from: the docs .md URL or the claude.com/pricing URL. | https://platform.claude.com/docs/en/about-claude/pricing.md |
| `recordType` | api_model for a model price row, plan for a Claude subscription plan or seat. | api_model |
| `source` | Which page the record came from: platform_docs or claude_com. | platform_docs |
| `name` | Model name as shown on the page (docs rows start with Claude), or the plan or seat name. | Claude Opus 4.5 |
| `description` | Tagline from the page: the model card subtitle or the plan subtitle. Empty for docs rows. | Daily driver for agentic coding and enterprise work |
| `family` | Model family word taken from the name: Fable, Mythos, Opus, Sonnet or Haiku. | Opus |
| `version` | Version token taken from the name, e.g. 5.5, 4.1 or preview. | 4.5 |
| `apiModelId` | API model id from the model deprecations page, matched by family and version. Docs rows only. | claude-opus-4-5-20251101 |
| `availability` | active, limited or retired, taken from the parenthetical in the docs model name. active for claude.com rows and plans. | active |
| `availabilityNote` | Parenthetical text next to the docs model name, e.g. limited availability. | limited availability |
| `promptLengthCondition` | Prompt-length tier for models priced by prompt length, e.g. Haiku 5.5. Empty otherwise. | for prompts up to 100,000 tokens |
| `inputPriceText` | Input price exactly as shown, footnote markers removed. | USD 5 / MTok |
| `outputPriceText` | Output price exactly as shown, footnote markers removed. | USD 25 / MTok |
| `inputPerMTok` | Base input price in USD per million tokens. | 5 |
| `cacheWrite5mPerMTok` | Price of a 5-minute prompt cache write in USD per million tokens. | 6.25 |
| `cacheWrite1hPerMTok` | Price of a 1-hour prompt cache write in USD per million tokens. Docs rows only. | 10 |
| `cacheReadPerMTok` | Price of a prompt cache hit or refresh in USD per million tokens. | 0.5 |
| `outputPerMTok` | Output price in USD per million tokens. | 25 |
| `batchInputPerMTok` | Batch processing input price in USD per million tokens. Docs rows only. | 2.5 |
| `batchOutputPerMTok` | Batch processing output price in USD per million tokens. Docs rows only. | 12.5 |
| `fastModeInputPerMTok` | Fast mode input price in USD per million tokens, for models that offer fast mode. | 10 |
| `fastModeOutputPerMTok` | Fast mode output price in USD per million tokens, for models that offer fast mode. | 50 |
| `toolUseSystemPromptTokensAuto` | Tokens added by the tool use system prompt when tool_choice is auto or none. | 286 |
| `toolUseSystemPromptTokensAny` | Tokens added by the tool use system prompt when tool_choice is any or tool. | 406 |
| `deprecationState` | Current state from the model deprecations page: Active, Deprecated or Retired. | Active |
| `deprecatedOn` | Date the model was deprecated, when it was. | June 5, 2026 |
| `tentativeRetirementDate` | Tentative or actual retirement date from the model deprecations page. | Not sooner than July 24, 2027 |
| `planName` | Name of the subscription plan card the record belongs to (Free, Pro, Max, Team, Enterprise). | Team |
| `planKey` | Stable plan key: free, pro, max, team, team_premium or enterprise. | pro |
| `priceText` | Price as shown on the plan card or seat. | USD 17 |
| `priceNote` | Small print under the price, e.g. billing terms. | Per month with annual subscription discount (USD 200 billed up front). USD 20 if billed monthly. |
| `monthlyPriceUsd` | Price in USD per month (per seat for seats) when billed monthly, or the card price when no monthly variant exists. | 20 |
| `annualPricePerMonthUsd` | Per-month price in USD when billed annually. | 17 |
| `annualTotalUsd` | Total billed up front for an annual subscription in USD. | 200 |
| `features` | Feature bullet points listed on the plan card. | \["Claude Code", "Projects"] |
| `ctaUrl` | Link of the plan card button, e.g. the sign-up page. | https://claude.ai/login?plan=pro |
| `currency` | Currency of all prices. | USD |
| `priceUnit` | What the prices are per: USD per million tokens, USD per month, USD per seat per month. | USD per million tokens |
| `pageTitle` | Title of the page the record came from. | Pricing |
| `scrapedAt` | ISO 8601 time of the run. | 2026-10-17T00:07:16.128Z |

### How to use Anthropic Pricing Scraper

1. Open the Actor in Apify Console and leave the default pricing page URL, or add claude.com/pricing to also get plans.
2. Choose the record types. api_model returns model prices, plan returns subscription plans. The default returns both where the page has them.
3. Optionally type model name words such as opus or sonnet into the model filter to keep only matching rows.
4. Set maxItems and click Start. The run normally ends within seconds.
5. Open the Output tab and export the dataset as JSON, CSV, Excel or XML, or read it through the API.

Tips: the limit maxItems is shared across all URLs of a run, rows are returned in page order, and a plan record is never removed by the model filter. To monitor prices, schedule the Actor daily and compare the number fields with the previous run.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrls` | array of URLs | Yes | Pricing pages to read. Supported: the platform.claude.com docs pricing page (also docs.anthropic.com and docs.claude.com addresses) and claude.com/pricing (www.anthropic.com/pricing redirects there). Other URLs are skipped with a warning. |
| `recordTypes` | array of strings | No | api_model and/or plan. Default both. |
| `modelFilter` | array of strings | No | Case-insensitive words that must appear in the model name, for example opus or haiku 5.5. Default: all models. |
| `maxItems` | integer | No | Maximum number of records for the whole run, 1-10000, default 200. |
| `proxyConfiguration` | object | No | Proxy settings. Default: no proxy, because the pages answer plain requests. |

```json
{
    "startUrls": [
        { "url": "https://platform.claude.com/docs/en/about-claude/pricing" },
        { "url": "https://claude.com/pricing" }
    ],
    "recordTypes": ["api_model", "plan"],
    "modelFilter": ["opus", "sonnet"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": false }
}
```

Addresses with a fragment such as pricing#model-pricing are accepted, and so are old docs addresses that redirect to the current documentation host. The legacy input key urls and plain string URLs are also accepted.

### Output

Each run writes one dataset. Here are real records from a run on the Claude API documentation page, with null fields left out:

```json
[
    {
        "recordType": "api_model",
        "source": "platform_docs",
        "name": "Claude Haiku 5.5",
        "family": "Haiku",
        "version": "5.5",
        "apiModelId": "claude-haiku-5-5",
        "availability": "active",
        "promptLengthCondition": "for prompts up to 100,000 tokens",
        "inputPerMTok": 0.1,
        "outputPerMTok": 0.5,
        "cacheReadPerMTok": 0.01,
        "batchInputPerMTok": 0.05,
        "batchOutputPerMTok": 0.25,
        "toolUseSystemPromptTokensAuto": 286,
        "deprecationState": "Active",
        "sourceUrl": "https://platform.claude.com/docs/en/about-claude/pricing.md",
        "id": "model:Claude Haiku 5.5:for prompts up to 100,000 tokens:platform_docs"
    },
    {
        "recordType": "plan",
        "source": "claude_com",
        "name": "Pro",
        "planKey": "pro",
        "monthlyPriceUsd": 20,
        "annualPricePerMonthUsd": 17,
        "annualTotalUsd": 200,
        "sourceUrl": "https://claude.com/pricing",
        "id": "plan:pro"
    }
]
```

Export formats: JSON, CSV, Excel, XML, RSS and HTML table.

### How much does it cost to scrape Anthropic pricing?

Anthropic Pricing Scraper is charged per result. You pay only for the records returned, and `maxItems` caps how many that can be. See the Pricing tab of this Actor for the current price. A default run returns about two dozen records. You can also set a maximum cost per run in the run options; the Actor then stops and says so in its status message.

### Use with AI agents (MCP)

Connect Anthropic Pricing Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

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

Example prompts:

1. "Get the current Claude Opus and Sonnet API prices per million tokens and tell me which is cheaper for input."
2. "List every Claude model that is retired or deprecated, with its API model ID and retirement date."
3. "What does the Claude Team standard seat cost per month when billed annually versus monthly?"

### Integrations and API

Run Anthropic Pricing 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/anthropic-pricing-scraper").call(run_input={
    "startUrls": [{"url": "https://platform.claude.com/docs/en/about-claude/pricing"}],
    "recordTypes": ["api_model"],
    "maxItems": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item["inputPerMTok"], item["outputPerMTok"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/anthropic-pricing-scraper').call({
    startUrls: [{ url: 'https://claude.com/pricing' }],
    recordTypes: ['plan'],
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~anthropic-pricing-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls": [{"url": "https://platform.claude.com/docs/en/about-claude/pricing"}], "maxItems": 50}'
```

The Integrations tab connects the Actor to Make, Zapier, n8n, Google Sheets and webhooks, so a price change can update a sheet or trigger an alert.

### FAQ

**Which pages does it read?**
The Claude API pricing page of the documentation, the model deprecations page of the documentation (for API model IDs and states), and the public claude.com pricing page. Nothing else is contacted.

**Why do claude.com rows have fewer fields than docs rows?**
The claude.com page shows only input, output and prompt caching prices. Batch, fast mode, tool use and lifecycle details exist only in the documentation, so those fields are null on claude.com rows.

**Why does one model appear twice?**
Some models are priced by prompt length. Each tier is its own row, and `promptLengthCondition` says which one it is. Row ids include the condition, so both rows are kept.

**Why did my run return 0 results?**
The URL was not a supported pricing page, the page was unreachable, or the filters removed everything. The status message of the run names the cause. Such runs still end as succeeded with no items.

**Are retired models included?**
Yes, while the documentation lists them. Use `availability` and `deprecationState` to tell them apart from active models.

**How fresh is the data?**
Every run reads the live pages, so the data is as current as the pages at the time of the run. Schedule the Actor to track changes over time.

**Do I need a proxy?**
Normally not. If a request is blocked, the Actor retries on a new connection; you can also enable Apify Proxy in the input.

**Can I get a price in another currency?**
No. Prices are returned in USD as the pages state them.

### Is it legal to scrape Anthropic?

Anthropic Pricing Scraper reads only publicly available pricing pages that load without logging in, and it collects no personal data. You are responsible for how you use the data and for following the terms of the sites you scrape and any rules that apply to you. This is not legal advice.

Anthropic Pricing Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by Anthropic.

### 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`):

Pricing pages to scrape. Supported: platform.claude.com/docs/en/about-claude/pricing (API model prices, also via docs.anthropic.com or docs.claude.com) and claude.com/pricing (plans, seats and API model cards; www.anthropic.com/pricing redirects there). Other URLs are skipped with a warning and return 0 items.

## `recordTypes` (type: `array`):

Which records to return: api_model (one row per model price row; Haiku 5.5 gives one row per prompt-length tier) and plan (Free, Pro, Max, Team seats, Enterprise from claude.com/pricing only). Default both. Docs URLs only hold api_model rows.

## `modelFilter` (type: `array`):

Keep only api_model rows whose name contains one of these words, case-insensitive, e.g. 'opus', 'haiku 5.5', 'sonnet'. Empty keeps all models. Plans are never filtered by it.

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

Maximum number of records to return across all URLs, 1-10000, default 200. The run stops once this many are saved, and you are charged only for records returned.

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

Proxy for requests, default none. Enable Apify Proxy only if the pages start blocking; blocked requests are retried on a new IP automatically.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://platform.claude.com/docs/en/about-claude/pricing"
    }
  ],
  "recordTypes": [
    "api_model"
  ],
  "modelFilter": [],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `prices` (type: `string`):

Dataset with one record per model price row or plan.

# 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://platform.claude.com/docs/en/about-claude/pricing"
        }
    ],
    "recordTypes": [
        "api_model"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/anthropic-pricing-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://platform.claude.com/docs/en/about-claude/pricing" }],
    "recordTypes": ["api_model"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/anthropic-pricing-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://platform.claude.com/docs/en/about-claude/pricing"
    }
  ],
  "recordTypes": [
    "api_model"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/anthropic-pricing-scraper --silent --output-dataset

```

## MCP server setup

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