# AI Coding Tool Pricing Tracker (`ianymu/ai-coding-tool-pricing-tracker`) Actor

Track pricing of all major AI coding tools (Cursor, Claude Code, GitHub Copilot, Aider, Continue, Sourcegraph Cody) and emit a normalized tier-by-tier dataset. For procurement, journalist comparisons, and devs comparing monthly costs without clicking through 7 pricing pages.

- **URL**: https://apify.com/ianymu/ai-coding-tool-pricing-tracker.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### What does AI Coding Tool Pricing Tracker do?

**AI Coding Tool Pricing Tracker** scrapes the **current monthly pricing** of every major AI coding assistant — **Cursor, Claude Code, GitHub Copilot, Aider, Continue, and Sourcegraph Cody** — and emits a single normalized dataset with **every tier, every monthly cost, and every advertised feature**. Instead of opening seven pricing pages and copying numbers into a spreadsheet, you run this Actor and get a ready-to-compare JSON / CSV / Excel table.

Run it once for a one-shot snapshot, or schedule it daily on the Apify platform to **build a pricing history** and detect changes the moment a vendor adjusts their plans.

This Actor is part of Ian Mu's 100-Apify-Actor portfolio for the AI / Claude tooling ecosystem ([github.com/ianymu](https://github.com/ianymu)) and pairs naturally with [`claude-verify-before-stop`](https://github.com/ianymu/claude-verify-before-stop) — a Claude Code hook that prevents Claude from declaring tasks done before verifying real output. Both projects share the same philosophy: **trust the underlying data source, not the AI's summary.**

### Why use AI Coding Tool Pricing Tracker?

- **Enterprise procurement** — When your team is choosing between Copilot Business ($19/user/mo) and Cursor Business, you want exact, dated pricing — not a six-month-old blog post.
- **Journalists & analysts** — Side-by-side comparison tables ready to drop into an article. Cite the `scrapedAt` timestamp for credibility.
- **Individual developers** — Decide whether Aider + your own Claude API key beats a $20/mo Cursor Pro subscription.
- **Change detection** — Run the Actor on a schedule, diff outputs day-over-day, and **get notified the moment Cursor raises Pro from $20 to $25** or GitHub launches a new tier.
- **Procurement-friendly format** — JSON / CSV / Excel export, ready for Sheets, Notion, Airtable, or your TCO model.

### How to use AI Coding Tool Pricing Tracker

1. Open the Actor in Apify Console and click the **Try Actor** button.
2. (Optional) Edit the **Tools to track** list if you only care about a subset. Default is all seven.
3. (Optional) Set **Currency label** — defaults to USD because that's what vendors quote.
4. Click **Start**. The run typically completes in well under a minute.
5. Open the **Output** tab and **download as CSV, JSON, or Excel**, or hit the Dataset API endpoint to integrate with your own pipeline.

### Input

Two simple fields, both optional with smart defaults:

| Field | Type | Default | Description |
|---|---|---|---|
| `toolsToTrack` | array of strings | all 7 | Which tools to scrape: `cursor`, `claude-code`, `github-copilot`, `aider`, `continue`, `cody` |
| `currency` | string enum | `USD` | Label attached to extracted prices (numeric values come from the vendor page as-is) |

Example input:

```json
{
    "toolsToTrack": ["cursor", "claude-code", "github-copilot"],
    "currency": "USD"
}
````

### Output

Each tool produces one row in the dataset. You can **download the dataset in various formats such as JSON, HTML, CSV, or Excel.**

Example output row:

```json
{
    "tool": "cursor",
    "toolName": "Cursor",
    "scrapedAt": "2026-05-21T03:14:00.000Z",
    "url": "https://www.cursor.com/pricing",
    "currency": "USD",
    "tierCount": 3,
    "tiers": [
        { "name": "Hobby", "priceMonthly": 0, "features": ["Limited completions", "Limited slow requests"] },
        { "name": "Pro", "priceMonthly": 20, "features": ["Unlimited completions", "500 fast requests / mo"] },
        { "name": "Business", "priceMonthly": 40, "features": ["Privacy mode enforced", "Centralized billing", "SSO"] }
    ]
}
```

A human-readable Markdown summary is also written to the key-value store as `pricing-report.md`.

### Data table

| Field | Type | Description |
|---|---|---|
| `tool` | string | Internal slug (e.g. `cursor`) |
| `toolName` | string | Display name (e.g. `Cursor`) |
| `scrapedAt` | ISO date | When this snapshot was captured |
| `url` | URL | Source pricing page |
| `currency` | string | USD / EUR / GBP label |
| `tiers` | array of objects | One entry per pricing tier |
| `tiers[].name` | string | `Free`, `Pro`, `Business`, `Enterprise`, etc. |
| `tiers[].priceMonthly` | number | null | Monthly cost; `null` = "contact sales" |
| `tiers[].features` | array of strings | Bullet points scraped from that tier's card |
| `tierCount` | integer | Number of tiers captured |

### Pricing / Cost estimation

This Actor is **extremely cheap to run**: a full snapshot of all 7 tools makes ~7 HTTP requests with no browser, no proxy, no JavaScript rendering. On Apify's free tier you can run it **many times per day** without burning meaningful compute units. Recommended cadence: daily or weekly for trend tracking.

How much does it cost to scrape AI coding tool pricing pages? Effectively a fraction of a cent per run.

### Tips or advanced options

- **Daily change detection** — Schedule the Actor to run every morning via Apify's scheduler. Compare today's dataset to yesterday's with a quick `diff` to spot price hikes the same day they go live.
- **Subset tracking** — Pass only the tools you care about in `toolsToTrack` to speed up runs further (although the full run is already < 1 min).
- **Graceful failure** — If a vendor changes their pricing page layout, that tool is logged as a `no_tiers_extracted` failure and the rest of the run still completes. Open an issue on the GitHub repo and the per-tool selector will be patched.
- **Integrate downstream** — Combine with Apify's webhook integrations to push pricing-change alerts to Slack, Telegram, or your data warehouse.

### FAQ, disclaimers, and support

**Is this legal?** Scraping publicly-listed pricing pages for personal/business research is well within standard practice. The Actor uses a clearly-labeled `User-Agent`, makes only ~1 request per second per vendor, and only retrieves the same HTML a regular browser would. No login is required.

**What if a vendor changes their pricing layout?** Each tool has its own dedicated parser. If a layout shift breaks one parser, the rest of the run still completes — the failed tool surfaces as a `no_tiers_extracted` entry in the logs. Please open an issue at the GitHub repo so the parser can be updated.

**Will you add tool X?** Yes — open an issue at [github.com/ianymu](https://github.com/ianymu) (or DM Ian Mu) with the pricing URL and we'll add it. The actor uses one parser per tool, so contributions are easy.

**Custom version?** Need this wired into your procurement / FinOps stack with Slack alerts and historical diffs? Open an issue and we can build a custom Actor on top.

Built by **Ian Mu** as part of his 100-Apify-Actor AI tooling portfolio. See also: [`claude-verify-before-stop`](https://github.com/ianymu/claude-verify-before-stop) — a Claude Code hook that enforces real verification before tasks are marked complete.

# Actor input Schema

## `toolsToTrack` (type: `array`):

Which AI coding tools to capture pricing for. Default is all seven.

## `currency` (type: `string`):

Label attached to extracted prices. Numeric values are taken directly from the vendor pricing page (vendors typically show USD).

## Actor input object example

```json
{
  "toolsToTrack": [
    "cursor",
    "claude-code",
    "github-copilot",
    "aider",
    "continue",
    "cody"
  ],
  "currency": "USD"
}
```

# Actor output Schema

## `results` (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 = {
    "toolsToTrack": [
        "cursor",
        "claude-code",
        "github-copilot",
        "aider",
        "continue",
        "cody"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("ianymu/ai-coding-tool-pricing-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 = { "toolsToTrack": [
        "cursor",
        "claude-code",
        "github-copilot",
        "aider",
        "continue",
        "cody",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("ianymu/ai-coding-tool-pricing-tracker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "toolsToTrack": [
    "cursor",
    "claude-code",
    "github-copilot",
    "aider",
    "continue",
    "cody"
  ]
}' |
apify call ianymu/ai-coding-tool-pricing-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/ai-coding-tool-pricing-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Coding Tool Pricing Tracker",
        "description": "Track pricing of all major AI coding tools (Cursor, Claude Code, GitHub Copilot, Aider, Continue, Sourcegraph Cody) and emit a normalized tier-by-tier dataset. For procurement, journalist comparisons, and devs comparing monthly costs without clicking through 7 pricing pages.",
        "version": "0.0",
        "x-build-id": "ecs6SWTz62tbANwQ9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~ai-coding-tool-pricing-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-ai-coding-tool-pricing-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ianymu~ai-coding-tool-pricing-tracker/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-ai-coding-tool-pricing-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ianymu~ai-coding-tool-pricing-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-ai-coding-tool-pricing-tracker",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "toolsToTrack": {
                        "title": "Tools to track",
                        "type": "array",
                        "description": "Which AI coding tools to capture pricing for. Default is all seven.",
                        "default": [
                            "cursor",
                            "claude-code",
                            "github-copilot",
                            "aider",
                            "continue",
                            "cody"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "currency": {
                        "title": "Currency label",
                        "enum": [
                            "USD",
                            "EUR",
                            "GBP"
                        ],
                        "type": "string",
                        "description": "Label attached to extracted prices. Numeric values are taken directly from the vendor pricing page (vendors typically show USD).",
                        "default": "USD"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```