Metaculus APImetaculus.com ↗
Access Metaculus prediction questions, community forecasts, resolution status, and question details via a structured API. Two endpoints, paginated results.
What is the Metaculus API?
The Metaculus API gives developers access to forecasting questions and prediction data from Metaculus.com across 2 endpoints. Use get_pending_resolution_questions to retrieve paginated lists of questions awaiting resolution — including forecaster counts, topics, categories, and subquestions — and get_question_detail to pull full metadata on any individual question, including resolution criteria, community vote score, and fine print.
curl -X GET 'https://api.parse.bot/scraper/54188bf5-5799-4d5a-b7cb-e1e69c3939eb/get_pending_resolution_questions?limit=5&offset=0' \ -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 metaculus-com-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: Metaculus SDK — browse pending resolution questions and drill into details."""
from parse_apis.metaculus_questions_api import Metaculus, QuestionType, QuestionNotFound
client = Metaculus()
# List pending resolution questions with a bounded iteration.
for question in client.questions.list_pending(limit=5):
print(question.title, question.nr_forecasters, question.question_type)
# Drill into one specific question by taking the first result.
first = client.questions.list_pending(limit=1).first()
if first:
detail = client.questions.get(question_id=str(first.id))
print(detail.title, detail.vote_score, detail.resolution_criteria)
# Inspect subquestions for group-type questions.
if detail.subquestions:
for sq in detail.subquestions[:3]:
print(sq.label, sq.status, sq.scheduled_resolve_time)
# Typed error handling for a non-existent question.
try:
client.questions.get(question_id="9999999")
except QuestionNotFound as exc:
print(f"Question not found: {exc.question_id}")
print("exercised: questions.list_pending / questions.get / subquestions access / QuestionNotFound")
Fetch questions with pending resolution status from Metaculus. Returns paginated results with question metadata, forecaster counts, topics, subquestions, and community predictions. Pagination is offset-based; use next_offset from a previous response to advance.
| Param | Type | Description |
|---|---|---|
| limit | integer | Number of questions per page. |
| offset | integer | Pagination offset. Use next_offset from a previous response to fetch the next page. |
{
"type": "object",
"fields": {
"has_more": "boolean, whether more pages exist",
"questions": "array of question objects with id, title, slug, url, status, topics, categories, nr_forecasters, question_type, and subquestions",
"next_offset": "integer or null, offset for next page",
"total_on_page": "integer, number of questions returned on this page",
"previous_offset": "integer or null, offset for previous page"
}
}About the Metaculus API
Endpoints Overview
The API exposes two endpoints. get_pending_resolution_questions returns a paginated list of Metaculus questions that are pending resolution. Each page yields an array of question objects with fields including id, title, slug, url, status, topics, categories, nr_forecasters, question_type, and any associated subquestions. Pagination is controlled via limit and offset parameters; use next_offset from a response to walk through subsequent pages, and check has_more to determine whether additional results exist.
Question Detail
get_question_detail accepts a question_id (the numeric Metaculus post ID) and returns a richer object for that single question. Response fields include title, status, resolved (boolean), topics, categories, fine_print, vote_score, and the full url and slug. This is the endpoint to use when you need resolution criteria or the community vote score for a specific question.
Data Shape and Coverage
The pending resolution endpoint is scoped to questions in a pending-resolution state; it does not return the full Metaculus question catalog. The subquestions field on list results lets you identify conditional or group questions without fetching each detail record individually. nr_forecasters gives the count of forecasters who have made predictions on a question, useful for filtering by prediction activity.
The Metaculus API is a managed, monitored endpoint for metaculus.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when metaculus.com 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 metaculus.com 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?+
- Track all Metaculus questions currently pending resolution to monitor imminent outcome decisions.
- Filter prediction questions by topic or category using the
topicsandcategoriesfields. - Display forecaster participation counts (
nr_forecasters) to surface the most-predicted questions. - Retrieve full resolution criteria and fine print for any question via
get_question_detail. - Identify group or conditional questions by inspecting the
subquestionsfield on list results. - Sort or rank questions by community
vote_scoreto highlight highest-engagement forecasts. - Build a resolution alert system by polling pending questions and detecting
resolvedstatus changes.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Metaculus have an official developer API?+
What does `get_pending_resolution_questions` return, and how does pagination work?+
questions field, each with metadata such as id, title, status, topics, categories, nr_forecasters, question_type, and subquestions. Use the limit parameter to set page size and pass next_offset from the previous response as the offset parameter for the next page. The has_more boolean tells you whether further pages exist.Does the API return community prediction distributions or probability values for questions?+
nr_forecasters) and vote scores (vote_score), but do not expose numerical probability distributions or individual forecast values. The API covers pending-resolution question metadata and single-question detail records. You can fork it on Parse and revise to add an endpoint that returns community prediction aggregates for a given question ID.Is the full Metaculus question catalog available, or only pending-resolution questions?+
get_pending_resolution_questions is scoped to questions in a pending-resolution state. Open, resolved, and archived questions are not covered by the list endpoint. You can fork this API on Parse and revise it to add endpoints that query other question states.What is the `fine_print` field returned by `get_question_detail`?+
fine_print contains supplementary resolution details that are separate from the main resolution criteria — typically edge cases, ambiguity rules, or additional conditions the question author specifies. It is returned as a plain string and may be empty for questions that have none.