Context APIcontext.dev ↗
Access Context.dev pricing plans and product changelog via API. Retrieve plan tiers, credit allowances, features, overage costs, and dated release notes.
What is the Context API?
This API exposes 2 endpoints covering context.dev's current pricing structure and product changelog. The get_pricing endpoint returns all plan tiers — Free, Developer, Pro, and Scale — with monthly and annual prices, credit allowances, and overage rates. The get_changelog endpoint returns up to 100 dated changelog entries ordered newest first, letting you programmatically track feature releases and service updates without visiting the site.
No input parameters required.
curl -X GET 'https://api.parse.bot/scraper/a0c609e9-bc29-483b-a9ea-5bd1fe799038/get_pricing' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace context-dev-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Context.dev API — pricing plans and product changelog."""
from parse_apis.context_dev_api import ContextDev, BadRequestError
client = ContextDev()
# List all available pricing plans with credit allowances and features.
for plan in client.plans.list(limit=10):
overage = f"${plan.overage_price_per_10k}/10k" if plan.overage_price_per_10k is not None else "n/a"
annual = f"${plan.annual_price}/yr" if plan.annual_price is not None else "no annual"
print(f"{plan.name}: ${plan.monthly_price}/mo, {annual}, {plan.monthly_credits} credits, overage {overage}")
for feat in plan.features:
print(f" - {feat.text}")
# Fetch the newest changelog entry and show its content.
entry = client.changelog_entries.list(limit=1).first()
if entry is not None:
print(f"\nLatest update ({entry.date}): {entry.title}")
if entry.content is not None:
print(entry.content[:200])
# Browse more changelog history; guard against invalid page_size.
try:
for entry in client.changelog_entries.list(page_size=5, limit=5):
print(f"[{entry.date}] {entry.title}")
except BadRequestError as e:
print(f"Bad request: {e}")
print("\nexercised: plans.list / changelog_entries.list")
Returns the pricing plans currently displayed on context.dev (one shape: Free, Developer, Pro, and Scale tiers) with monthly and annual prices in USD, monthly credit allowance, feature bullets (with a detail note when the site provides one), and overage cost per 10K credits where the plan has overage. annual_price is null for plans without an annual option (the Free tier) and overage_price_per_10k is absent for plans without overage. Loads the pricing page and then the site's plan-configuration script, so a call costs a handful of requests and a few seconds.
No input parameters required.
{
"type": "object",
"fields": {
"plans": "array of plan objects with name, description, monthly_price (USD integer), annual_price (USD integer or null), monthly_credits, credit_cadence, features (array of {text, detail?}), and overage_price_per_10k (USD, present only for plans with overage)"
},
"sample": {
"data": {
"plans": [
{
"name": "Free",
"features": [
{
"text": "No overage"
},
{
"text": "30 API calls per minute"
},
{
"text": "Scrape 1,000 pages"
},
{
"text": "Pull 10K logos (one-time quota)",
"detail": "Separate quota via Logo Link — not deducted from your credits"
},
{
"text": "Email support"
}
],
"description": "For testing out the API",
"annual_price": null,
"monthly_price": 0,
"credit_cadence": "monthly",
"monthly_credits": 1000
},
{
"name": "Developer",
"features": [
{
"text": "$15 per 10K credits overage"
},
{
"text": "60 API calls per minute"
},
{
"text": "Scrape 10,000 pages"
},
{
"text": "1,000 structured extracts",
"detail": "10 credits per call"
},
{
"text": "Email support"
}
],
"description": "Building your first real workflow.",
"annual_price": 250,
"monthly_price": 25,
"credit_cadence": "monthly",
"monthly_credits": 10000,
"overage_price_per_10k": 15
}
]
},
"status": "success"
}
}About the Context API
Pricing Plans
The get_pricing endpoint takes no inputs and returns a plans array where each object includes name, description, monthly_price, annual_price, monthly_credits, credit_cadence, features, and overage_ cost details. This covers all four published tiers on context.dev — Free, Developer, Pro, and Scale — in a single call, making it straightforward to compare tiers or detect price changes over time.
Changelog Entries
The get_changelog endpoint accepts an optional limit integer (clamped between 1 and 100) and returns a total count alongside an entries array. Each entry carries a title, date, id, and content summary. Entries are ordered newest first, so setting limit=5 gives you the five most recent releases without fetching the full history.
Typical Usage Patterns
Because get_pricing reflects the live pricing page, polling it periodically lets you detect plan additions, price changes, or updated credit allowances without manual checks. get_changelog is useful for monitoring when context.dev ships new functionality — for example, checking whether a feature you depend on has changed or whether a new API endpoint has been announced.
The Context API is a managed, monitored endpoint for context.dev — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when context.dev changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official context.dev API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Monitor context.dev pricing changes and alert your team when plan prices or credit allowances update.
- Compare monthly vs. annual pricing across all four tiers to model cost projections for a SaaS budget.
- Ingest the changelog into an internal feed to track when context.dev ships new features relevant to your integration.
- Scrape overage costs from the pricing response to calculate true cost-per-credit at different usage levels.
- Build a changelog digest that surfaces the latest N entries using the
limitparameter for a weekly summary email. - Audit
featuresfields across plan tiers to determine the minimum plan required for a specific capability. - Track changelog entry IDs over time to detect new releases since your last poll.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 200 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
| Team | $300/mo | 20,000 | 300 req/min |
| Company | $1,000/mo | 100,000 | 500 req/min |
Each endpoint has a fixed posted price per successful call — most fall between 1 and 10 credits — shown on this API's page before you run it. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does context.dev offer an official developer API?+
What does `get_changelog` return and how do I limit results?+
total integer and an entries array, each entry containing title, date, id, and content. Pass the optional limit parameter (integer, 1–100) to control how many entries come back. Entries are always ordered newest first, so limit=1 returns only the latest release.Does `get_pricing` include overage pricing and credit cadence details?+
plans array includes overage_ cost details alongside monthly_credits and credit_cadence, so you can determine both the included credit volume and the cost per credit beyond that limit.Can I retrieve historical pricing snapshots or archived changelog content beyond 100 entries?+
get_pricing reflects the current live pricing page only, and get_changelog is capped at 100 entries per call with no offset or pagination parameter. You can fork this API on Parse and revise it to add a pagination offset or a historical-snapshot storage layer.