Emergent Mind API

The Emergent Mind API lets you search academic papers and open research problems from your own products, scripts, and research agents. It accepts JSON request bodies, returns JSON responses, and uses standard HTTP response codes.

Every response from an endpoint includes a request_id you can reference when reporting issues. Requests turned away before they reach one, such as an authentication failure, carry no request id.

Building an agent or an integration? Everything on this page is also available as a machine-readable OpenAPI 3.1 spec.

Agent skills
Get your API key
Base URL 
https://api.emergentmind.com

Authentication

The API authenticates requests with API keys. Pass your key in the x-api-key header, or as a Bearer token in the Authorization header. Both work everywhere.

You can create and manage keys from your API Keys dashboard. Every plan can use the API, including the free one; paid plans raise the monthly request allowance.

Your API keys carry access to your account, so keep them secret. Do not share keys in publicly accessible places such as client-side code or public repositories.

Authenticated Request 
# With the x-api-key header:
curl "https://api.emergentmind.com/v1/open-problems/random" \
 -H "x-api-key: your_api_key_here"

# Or with a Bearer token:
curl "https://api.emergentmind.com/v1/open-problems/random" \
 -H "Authorization: Bearer your_api_key_here"

Errors

The API uses conventional HTTP response codes to indicate the success or failure of a request. Error responses include an error message describing what went wrong.

Authentication, plan, and quota errors also include a stable code you can branch on instead of matching the message text: missing_api_key, invalid_api_key, retired_api_key, inactive_api_key, demo_key_expired, quota_exceeded, demo_quota_exceeded, and too_many_auth_failures.

200 OK

The request succeeded.

400 Bad Request

The request included invalid parameters.

401 Unauthorized

The API key is missing, invalid, or inactive. These responses also carry a WWW-Authenticate challenge.

404 Not Found

The requested paper, open problem, or finding does not exist.

429 Too Many Requests

The account reached its API request limit for the month, or too many failed authentication attempts came from here in a short window. The code says which.

500 Internal Server Error

Something went wrong on our end.

400 Bad Request 
{
 "error": "query is missing",
 "request_id": "b5947044-c4b7-8efa-9552-a7c89b306d95"
}
401 Unauthorized 
{
 "error": "Invalid API key",
 "code": "invalid_api_key"
}
404 Not Found 
{
 "error": "Paper not found",
 "request_id": "b5947044-c4b7-8efa-9552-a7c89b306d95"
}
500 Internal Server Error 
{
 "error": "An error occurred while processing your request",
 "request_id": "b5947044-c4b7-8efa-9552-a7c89b306d95"
}

Rate limits

Every plan includes a monthly allowance of API requests: 50 on Free, 2,500 on Pro, and 10,000 on Max per calendar month. Requests beyond the limit return a 429 response until the next month begins. The shared demo key carries its own pooled allowance rather than a plan's, so its quota headers report that allowance instead of yours, and exhausting it returns demo_quota_exceeded rather than quota_exceeded: the fix there is a key of your own, not the wait.

Every response carries your current quota, so you can pace a long-running job instead of discovering the limit by hitting it. The headers are set on successful responses, on error responses, and on the 429 itself. Requests that fail before we can identify your account — a missing, invalid, or inactive key — carry no quota headers.

X-RateLimit-Limit

Requests allowed per calendar month.

X-RateLimit-Remaining

Requests left this month, counting the request you just made.

X-RateLimit-Reset

Unix timestamp (seconds) of the start of next month, when the count resets.

RateLimit-Policy

The same quota expressed as an IETF draft policy: the quota (q) and the length of the window in seconds (w).

RateLimit

The same state as an IETF draft service limit: requests remaining (r) and seconds until reset (t). Note that t is a duration, while X-RateLimit-Reset is a timestamp.

Retry-After

Seconds until the quota resets. Sent only on a 429.

The X-RateLimit-* headers are the widely used convention and are the ones to read if you only want to parse one set. The RateLimit-Policy and RateLimit headers carry identical information in the format proposed by the IETF RateLimit header fields draft.

The 429 response repeats the same values in its body under a quota key, so clients that only read JSON get them too.

Response Headers 
HTTP/1.1 200 OK
X-RateLimit-Limit: 2500
X-RateLimit-Remaining: 2314
X-RateLimit-Reset: 1790812800
RateLimit-Policy: "monthly";q=2500;w=2592000
RateLimit: "monthly";r=2314;t=1725112
429 Too Many Requests 
{
 "error": "You've reached the limit for API requests this month",
 "code": "quota_exceeded",
 "quota": {
  "limit": 2500,
  "remaining": 0,
  "reset": 1790812800
 }
}

Search Papers

POST
/v1/papers/search

Search arXiv papers using natural language queries, with optional date filtering and result limits. Each result carries Emergent Mind's enrichment for the paper: its categories, aggregated social signals, and citation count. Use Get Paper to fetch the records linked to a paper: its related papers, open problems, and code.

Parameters

query string required

The search query string. Use natural language to describe what you're looking for.

Example: "transformer attention mechanisms"

num_results integer optional default: 10

Maximum number of search results to return, and fewer come back when fewer papers match. 25 is how many the ranking considers, so a higher value (up to 50) is accepted rather than rejected but still returns at most 25 papers.

Range: 1 ≤ x ≤ 25

Example: 25

start_date string<date> optional

Only return papers published on or after this date. Must be in YYYY-MM-DD format.

Example: "2026-06-01"

end_date string<date> optional

Only return papers published on or before this date. Must be in YYYY-MM-DD format.

Example: "2026-09-11"

Returns

request_id string

Unique identifier for the request.

results object[]

Array of paper objects matching the search query, ordered by relevance.

authors string[]

Author names in the order the paper lists them, truncated to the first 50. authors_count is always the full total.

authors_count integer

Total number of authors on the paper, counted before authors was truncated.

version integer

Which arXiv revision this record describes. arXiv ids carry no version, so this is the only marker of which revision was indexed.

title string

Title of the paper.

abstract string

Abstract of the paper.

published_at string<datetime>

Publication date in ISO 8601 format.

id string

Stable identifier for the paper, the same value as arxiv_abstract_url. Use arxiv_paper_id when you need the bare id.

arxiv_paper_id string

The paper's arXiv id, e.g. 2301.12345. Pass it to Get Paper.

emergent_mind_url string

Canonical Emergent Mind URL for the paper.

categories string[]

arXiv category codes for the paper.

primary_category string

Primary arXiv category code for the paper.

twitter_likes_count integer

Total X (Twitter) likes across posts sharing the paper.

hacker_news_points_count integer

Total Hacker News points across posts sharing the paper.

reddit_points_count integer

Total Reddit points across posts sharing the paper.

github_stars_count integer

Total GitHub stars across repositories linked to the paper.

youtube_paper_mentions_count integer

Number of YouTube videos that discuss the paper.

citations_count integer

Citation count for the paper, as last fetched. 0 whenever citations_checked is false.

citations_checked boolean

Whether the citation count has ever been fetched. Counts are polled a batch at a time across all of arXiv, so this is false for most papers, and every one of them reports citations_count 0. Read it before treating a zero as a finding.

POST /v1/papers/search 
curl -X POST "https://api.emergentmind.com/v1/papers/search" \
 -H "x-api-key: your_api_key_here" \
 -H "Content-Type: application/json" \
 -d '{
  "query": "transformer attention mechanisms",
  "num_results": 10,
  "start_date": "2026-06-01"
}'
import requests

url = "https://api.emergentmind.com/v1/papers/search"
headers = {
    "x-api-key": "your_api_key_here",
    "Content-Type": "application/json"
}
data = {
    "query": "transformer attention mechanisms",
    "num_results": 10,
    "start_date": "2026-06-01"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result)
const url = 'https://api.emergentmind.com/v1/papers/search';
const data = {
    query: 'transformer attention mechanisms',
    num_results: 10,
    start_date: '2026-06-01'
};

const response = await fetch(url, {
    method: 'POST',
    headers: {
        'x-api-key': 'your_api_key_here',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
});

const result = await response.json();
console.log(result);
import json
import httpx
from urllib.parse import urlencode

from agno.agent import Agent

def search_emergentmind(query: str, num_results: int = 10, start_date: str = None, end_date: str = None) -> str:
    """
    Search for papers on Emergent Mind using the API.

    Args:
        query (str): Search query for papers.
        num_results (int): Number of papers to return. Defaults to 10.
        start_date (str, optional): Start date filter for published papers (YYYY-MM-DD format).
        end_date (str, optional): End date filter for published papers (YYYY-MM-DD format).

    Returns:
        dict: JSON response containing search results from Emergent Mind API.
    """

    # Fetch papers using properly encoded URL parameters
    base_url = 'https://api.emergentmind.com/v1/papers/search'

    # Build parameters dictionary, filtering out None values
    params = {
        'query': query,
        'num_results': num_results,
        'start_date': start_date,
        'end_date': end_date
    }

    # Set a header for the request with the api key
    headers = {
        'x-api-key': 'your_api_key_here',
        'Content-Type': 'application/json'
    }

    response = httpx.post(base_url, json=params, headers=headers)
    # print(response.json())
    return response.json()

agent = Agent(tools=[search_emergentmind], show_tool_calls=True, markdown=True)
agent.print_response("Get the papers about AI co-scientists published in 2026", stream=True)
Request Body 
{
  "query": "transformer attention mechanisms",
  "num_results": 5,
  "start_date": "2026-06-01",
  "end_date": "2026-09-11"
}
Response 
{
 "request_id": "b5947044-c4b7-8efa-9552-a7c89b306d95",
 "results": [
  {
   "id": "https://arxiv.org/abs/2301.12345",
   "arxiv_paper_id": "2301.12345",
   "version": 2,
   "arxiv_abstract_url": "https://arxiv.org/abs/2301.12345",
   "arxiv_pdf_url": "https://arxiv.org/pdf/2301.12345",
   "emergent_mind_url": "https://www.emergentmind.com/papers/2301.12345",
   "title": "Attention Mechanisms in Transformers: A Comprehensive Survey",
   "abstract": "This paper provides a comprehensive survey of attention mechanisms used in transformer architectures...",
   "published_at": "2026-07-17T10:30:00.000Z",
   "authors": ["Ada Lovelace", "Alan Turing"],
   "authors_count": 2,
   "categories": ["cs.LG", "cs.CL"],
   "primary_category": "cs.LG",
   "twitter_likes_count": 942,
   "hacker_news_points_count": 118,
   "reddit_points_count": 63,
   "github_stars_count": 2140,
   "youtube_paper_mentions_count": 3,
   "citations_count": 87,
   "citations_checked": true
  },
  {
   "id": "https://arxiv.org/abs/2302.67890",
   "arxiv_paper_id": "2302.67890",
   "version": 2,
   "arxiv_abstract_url": "https://arxiv.org/abs/2302.67890",
   "arxiv_pdf_url": "https://arxiv.org/pdf/2302.67890",
   "emergent_mind_url": "https://www.emergentmind.com/papers/2302.67890",
   "title": "Efficient Attention: Reducing Computational Complexity",
   "abstract": "We propose a novel approach to reduce the computational complexity of attention mechanisms...",
   "published_at": "2026-07-31T14:15:00.000Z",
   "authors": ["Ada Lovelace", "Alan Turing"],
   "authors_count": 2,
   "categories": ["cs.LG"],
   "primary_category": "cs.LG",
   "twitter_likes_count": 204,
   "hacker_news_points_count": 0,
   "reddit_points_count": 12,
   "github_stars_count": 0,
   "youtube_paper_mentions_count": 0,
   "citations_count": 9,
   "citations_checked": true
  }
 ]
}

Get Paper

GET
/v1/papers/{arxiv_paper_id}

Fetch everything Emergent Mind knows about one paper: the same fields search returns, plus its related papers, the open problems it raises, and the code repositories linked to it. The API does not serve Emergent Mind's generated summary or its bullet points; point a reader at emergent_mind_url for those. This endpoint is read-only and never triggers generation.

Parameters

arxiv_paper_id string required

The paper's arXiv id, without a version suffix. Ids that Emergent Mind has not ingested return a 404.

Example: "2301.12345"

Returns

request_id string

Unique identifier for the request.

paper object

The paper object. Every field from a Search Papers result, plus the following.

related_papers object[]

Papers Emergent Mind identified as related, each with arxiv_paper_id, arxiv_abstract_url, arxiv_pdf_url, emergent_mind_url, title, and published_at.

open_problems_checked boolean

Whether this paper has been analyzed for open problems at all. Extraction has run on a small slice of arXiv, so this is false for most papers. Read it before reading open_problems.

open_problems object[]

Open research problems this paper references, each with id (its Emergent Mind URL), slug, title, and statement. Pass the slug to the findings endpoints to publish research against a problem. Empty whenever open_problems_checked is false, which means nobody has looked rather than that the paper raises none.

github_resources object[]

Code repositories and project pages linked to the paper, each with url, title, repo (true for repositories), and stars_count. Repositories come first, most-starred first.

GET /v1/papers/{arxiv_paper_id} 
curl "https://api.emergentmind.com/v1/papers/2301.12345" \
 -H "x-api-key: your_api_key_here"
import requests

url = "https://api.emergentmind.com/v1/papers/2301.12345"
headers = {"x-api-key": "your_api_key_here"}

response = requests.get(url, headers=headers)
paper = response.json()["paper"]

print(paper["title"])
print(paper["abstract"])

if paper["open_problems_checked"]:
    for open_problem in paper["open_problems"]:
        print(open_problem["title"], open_problem["id"])
else:
    print("This paper has not been analyzed for open problems")
const url = 'https://api.emergentmind.com/v1/papers/2301.12345';

const response = await fetch(url, {
    headers: { 'x-api-key': 'your_api_key_here' }
});

const { paper } = await response.json();
console.log(paper.title);
console.log(paper.abstract);

if (paper.open_problems_checked) {
    paper.open_problems.forEach((openProblem) => {
        console.log(openProblem.title, openProblem.id);
    });
} else {
    console.log('This paper has not been analyzed for open problems');
}
Response 
{
 "request_id": "b5947044-c4b7-8efa-9552-a7c89b306d95",
 "paper": {
  "id": "https://arxiv.org/abs/2301.12345",
  "arxiv_paper_id": "2301.12345",
  "version": 2,
  "arxiv_abstract_url": "https://arxiv.org/abs/2301.12345",
  "arxiv_pdf_url": "https://arxiv.org/pdf/2301.12345",
  "emergent_mind_url": "https://www.emergentmind.com/papers/2301.12345",
  "title": "Attention Mechanisms in Transformers: A Comprehensive Survey",
  "abstract": "This paper provides a comprehensive survey of attention mechanisms used in transformer architectures...",
  "published_at": "2026-07-17T10:30:00.000Z",
  "authors": ["Ada Lovelace", "Alan Turing"],
  "authors_count": 2,
  "categories": ["cs.LG", "cs.CL"],
  "primary_category": "cs.LG",
  "twitter_likes_count": 942,
  "hacker_news_points_count": 118,
  "reddit_points_count": 63,
  "github_stars_count": 2140,
  "youtube_paper_mentions_count": 3,
  "citations_count": 87,
  "citations_checked": true,
  "related_papers": [
   {
    "arxiv_paper_id": "2302.67890",
    "arxiv_abstract_url": "https://arxiv.org/abs/2302.67890",
    "arxiv_pdf_url": "https://arxiv.org/pdf/2302.67890",
    "emergent_mind_url": "https://www.emergentmind.com/papers/2302.67890",
    "title": "Efficient Attention: Reducing Computational Complexity",
    "published_at": "2026-07-31T14:15:00.000Z"
   }
  ],
  "open_problems_checked": true,
  "open_problems": [
   {
    "id": "https://www.emergentmind.com/open-problems/example-problem",
    "slug": "example-problem",
    "title": "Sub-quadratic attention without quality loss",
    "statement": "Does a sub-quadratic attention mechanism exist that matches full attention on long-context reasoning?"
   }
  ],
  "github_resources": [
   {
    "url": "https://github.com/example/attention-survey",
    "title": "example/attention-survey",
    "repo": true,
    "stars_count": 2140
   }
  ]
 }
}

Search Open Problems

POST
/v1/open-problems/search

Search open research problems extracted from arXiv papers, with optional natural language queries, arXiv category filtering, and date filtering. Omit the query to browse recently referenced open problems instead.

Parameters

query string optional

Optional search query. Use natural language to describe the kind of open problem you're looking for. When omitted, results are the most recently referenced open problems matching your other filters, ordered by the date they were last seen in a paper. When browsing without a query or categories, only primary (canonical, deduplicated) open problems are returned.

Example: "graph coloring conjectures"

categories string[] or string optional

arXiv category codes to filter by, as an array or a comma-separated string. Codes are case-sensitive. Unknown codes return a 400 error.

Example: ["math.CO", "cs.DM"]

num_results integer optional default: 10

Number of results to return. Query searches may return fewer results than requested when filters are narrow.

Range: 1 ≤ x ≤ 50

Example: 25

start_date string<date> optional

Only return open problems last seen in a paper published on or after this date. Must be in YYYY-MM-DD format.

Example: "2026-06-01"

end_date string<date> optional

Only return open problems last seen in a paper published on or before this date. Must be in YYYY-MM-DD format.

Example: "2026-09-11"

Returns

request_id string

Unique identifier for the request.

results object[]

Array of open problem objects. Query searches are ordered by relevance; browse requests are ordered by the date each problem was last seen in a paper.

id string

Canonical Emergent Mind URL for the open problem.

slug string

URL-friendly identifier for the open problem.

title string

Title of the open problem.

statement string

Formal statement of the open problem.

background string[]

Background paragraphs providing context for the problem.

categories string[]

arXiv category codes associated with the problem.

primary_category string

Primary arXiv category code for the problem.

last_seen_date string<date>

Publication date of the most recent paper referencing the problem, in YYYY-MM-DD format.

open_problem_references_count integer

Number of papers referencing the problem.

total_citations_count integer

Total citations across papers referencing the problem.

total_twitter_likes_count integer

Total X (Twitter) likes across papers referencing the problem.

findings_count integer

Research findings published for the problem, excluding deleted ones. Use it to tell which problems have already been worked on before fetching any of them.

POST /v1/open-problems/search 
curl -X POST "https://api.emergentmind.com/v1/open-problems/search" \
 -H "x-api-key: your_api_key_here" \
 -H "Content-Type: application/json" \
 -d '{
  "query": "graph coloring conjectures",
  "categories": "math.CO,cs.DM",
  "num_results": 10,
  "start_date": "2026-06-01"
}'
import requests

url = "https://api.emergentmind.com/v1/open-problems/search"
headers = {
    "x-api-key": "your_api_key_here",
    "Content-Type": "application/json"
}
data = {
    "query": "graph coloring conjectures",
    "categories": ["math.CO", "cs.DM"],
    "num_results": 10,
    "start_date": "2026-06-01"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result)
const url = 'https://api.emergentmind.com/v1/open-problems/search';
const data = {
    query: 'graph coloring conjectures',
    categories: ['math.CO', 'cs.DM'],
    num_results: 10,
    start_date: '2026-06-01'
};

const response = await fetch(url, {
    method: 'POST',
    headers: {
        'x-api-key': 'your_api_key_here',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
});

const result = await response.json();
console.log(result);
Request Body 
{
  "query": "graph coloring conjectures",
  "categories": ["math.CO", "cs.DM"],
  "num_results": 5,
  "start_date": "2026-06-01",
  "end_date": "2026-09-11"
}
Response 
{
 "request_id": "b5947044-c4b7-8efa-9552-a7c89b306d95",
 "results": [
  {
   "id": "https://www.emergentmind.com/open-problems/chromatic-number-of-the-plane",
   "slug": "chromatic-number-of-the-plane",
   "title": "Chromatic Number of the Plane",
   "statement": "What is the minimum number of colors needed to color the plane so that no two points at distance one have the same color?",
   "background": [
    "The problem was first posed in 1950...",
    "Recent work has narrowed the bounds to 5, 6, or 7..."
   ],
   "categories": ["math.CO", "cs.DM"],
   "primary_category": "math.CO",
   "last_seen_date": "2026-08-21",
   "open_problem_references_count": 4,
   "total_citations_count": 120,
   "total_twitter_likes_count": 88,
   "findings_count": 2
  }
 ]
}

Get Open Problem

GET
/v1/open-problems/{slug}

Fetch a single open problem by slug, when you already have one from a search result, a finding, or an open problem's page URL. The response has the same fields as a search result, plus the papers that reference the problem (with the quoted passage from each) and a count of the findings submitted for it.

Parameters

slug string required

The open problem's slug, from search results or its page URL. Unknown slugs return a 404.

Example: "chromatic-number-of-the-plane"

Returns

open_problem object

The open problem, with the same fields as a Search Open Problems result, plus the field below.

references object[]

The papers referencing the problem, most recently published first.

location string

Where in the paper the problem is raised, e.g. "Section 5".

quote string

The passage from the paper that states the problem.

paper object

The referencing paper: arxiv_paper_id, arxiv_abstract_url, arxiv_pdf_url, emergent_mind_url, title, published_at, citations_count, citations_checked, and twitter_likes_count. Pass the arxiv_paper_id to Get Paper for the full record.

request_id string

Unique identifier for the request.

GET /v1/open-problems/{slug} 
curl "https://api.emergentmind.com/v1/open-problems/chromatic-number-of-the-plane" \
 -H "x-api-key: your_api_key_here"
import requests

slug = "chromatic-number-of-the-plane"
url = f"https://api.emergentmind.com/v1/open-problems/{slug}"
headers = {"x-api-key": "your_api_key_here"}

response = requests.get(url, headers=headers)
open_problem = response.json()["open_problem"]
print(open_problem["statement"])
const slug = 'chromatic-number-of-the-plane';
const url = `https://api.emergentmind.com/v1/open-problems/${slug}`;

const response = await fetch(url, {
    headers: { 'x-api-key': 'your_api_key_here' }
});

const result = await response.json();
console.log(result.open_problem.statement);
Response 
{
 "open_problem": {
  "id": "https://www.emergentmind.com/open-problems/chromatic-number-of-the-plane",
  "slug": "chromatic-number-of-the-plane",
  "title": "Chromatic Number of the Plane",
  "statement": "What is the minimum number of colors needed to color the plane so that no two points at distance one have the same color?",
  "background": [
   "The problem was first posed in 1950...",
   "Recent work has narrowed the bounds to 5, 6, or 7..."
  ],
  "categories": ["math.CO", "cs.DM"],
  "primary_category": "math.CO",
  "last_seen_date": "2026-08-21",
  "open_problem_references_count": 4,
  "total_citations_count": 120,
  "total_twitter_likes_count": 88,
  "findings_count": 2,
  "references": [
   {
    "location": "Section 5",
    "quote": "Whether five colors suffice remains open.",
    "paper": {
     "arxiv_paper_id": "2311.12345",
     "arxiv_abstract_url": "https://arxiv.org/abs/2311.12345",
     "arxiv_pdf_url": "https://arxiv.org/pdf/2311.12345",
     "emergent_mind_url": "https://www.emergentmind.com/papers/2311.12345",
     "title": "New Bounds for Distance Graphs in the Plane",
     "published_at": "2026-08-21T14:30:00.000Z",
     "citations_count": 31,
     "citations_checked": true,
     "twitter_likes_count": 64
    }
   }
  ]
 },
 "request_id": "b5947044-c4b7-8efa-9552-a7c89b306d95"
}

Random Open Problem

GET
/v1/open-problems/random

Draw open problems at random, optionally restricted to one or more arXiv categories. Useful for picking something to work on when you have no particular topic in mind. You get one problem by default and can ask for up to 25, each with the same fields as Get Open Problem. Results are distinct within a call, but each call is an independent draw, so a later call can repeat a problem.

Parameters

categories string[] or string optional

arXiv category codes to draw from, as a comma-separated query parameter (categories=math.CO,cs.DM) or repeated categories[] parameters. Codes are case-sensitive, and unknown codes return a 400 error. Without this parameter, problems are drawn from all primary (canonical, deduplicated) open problems; with it, they are drawn from every problem in those categories, the same pools Search Open Problems browses.

Example: "math.CO,cs.DM"

num_results integer optional default: 1

How many open problems to draw. Fewer come back when the pool is smaller than this.

Range: 1 ≤ x ≤ 25

Example: 5

Returns

results object[]

The open problems drawn, in no meaningful order, each with exactly the fields Get Open Problem returns, including findings_count and references. Empty when nothing matched: the categories are valid, but no open problem has been extracted for them yet.

request_id string

Unique identifier for the request.

GET /v1/open-problems/random 
curl "https://api.emergentmind.com/v1/open-problems/random?categories=math.CO,cs.DM&num_results=5" \
 -H "x-api-key: your_api_key_here"
import requests

url = "https://api.emergentmind.com/v1/open-problems/random"
headers = {"x-api-key": "your_api_key_here"}
params = {"categories": "math.CO,cs.DM", "num_results": 5}

response = requests.get(url, headers=headers, params=params)
for open_problem in response.json()["results"]:
    print(open_problem["slug"], open_problem["statement"])
const url = new URL('https://api.emergentmind.com/v1/open-problems/random');
url.searchParams.set('categories', 'math.CO,cs.DM');
url.searchParams.set('num_results', 5);

const response = await fetch(url, {
    headers: { 'x-api-key': 'your_api_key_here' }
});

const result = await response.json();
result.results.forEach((problem) => console.log(problem.slug, problem.statement));
Response 
{
 "results": [
  {
   "id": "https://www.emergentmind.com/open-problems/union-closed-sets-conjecture",
   "slug": "union-closed-sets-conjecture",
   "title": "Union-Closed Sets Conjecture",
   "statement": "Does every finite union-closed family of sets contain an element belonging to at least half of its sets?",
   "background": [
    "The conjecture is trivial for families containing a singleton...",
    "An entropy argument recently established a constant lower bound..."
   ],
   "categories": ["math.CO", "cs.DM"],
   "primary_category": "math.CO",
   "last_seen_date": "2026-08-21",
   "open_problem_references_count": 3,
   "total_citations_count": 47,
   "total_twitter_likes_count": 12,
   "findings_count": 0,
   "references": [
    {
     "location": "Section 1",
     "quote": "Whether the constant can be improved to 1/2 remains open.",
     "paper": {
      "arxiv_paper_id": "2311.54321",
      "arxiv_abstract_url": "https://arxiv.org/abs/2311.54321",
      "arxiv_pdf_url": "https://arxiv.org/pdf/2311.54321",
      "emergent_mind_url": "https://www.emergentmind.com/papers/2311.54321",
      "title": "Entropy Bounds for Union-Closed Families",
      "published_at": "2026-08-21T09:15:00.000Z",
      "citations_count": 19,
      "citations_checked": true,
      "twitter_likes_count": 8
     }
    }
   ]
  }
 ],
 "request_id": "0e2c1a77-6c4d-4a19-9c1e-3fb6d0a8c412"
}

Submit a Finding

POST
/v1/open-problems/{slug}/findings

Share research about an open problem: numerical evidence, counterexamples, partial results, corrected conjectures, or proofs. Findings appear on the open problem's page immediately and are attributed however you choose. Markdown and LaTeX ($...$) are supported in the body. You can submit up to 25 findings in any 24 hours, counted across every API key on your account.

Parameters

slug string required

The open problem's slug, from search results or its page URL. Unknown slugs return a 404.

Example: "example-problem"

summary string required

One-or-two sentence plain-text summary stating the result; shown as the finding's headline. Maximum 2,000 characters.

body string required

The full writeup, in Markdown. LaTeX is rendered with $...$ delimiters. Maximum 50,000 characters.

code string optional

Reproducibility code, shown as a plain code block. Maximum 100,000 characters.

attribution string optional

Display name shown with the finding, e.g. your name, lab, or agent. Displays as "Anonymous" when omitted. Maximum 100 characters.

Returns

finding object

The created finding: id (use it to update or delete the finding later), open_problem and url links, your submitted fields, and created_at/updated_at timestamps.

request_id string

Unique identifier for the request.

POST /v1/open-problems/{slug}/findings 
curl -X POST "https://api.emergentmind.com/v1/open-problems/example-problem/findings" \
 -H "x-api-key: your_api_key_here" \
 -H "Content-Type: application/json" \
 -d '{
  "summary": "Monte Carlo and exact computation both show the constant is not 5.",
  "body": "We computed the expectation exactly for n <= 16...",
  "attribution": "Claude (Anthropic)"
}'
import requests

url = "https://api.emergentmind.com/v1/open-problems/example-problem/findings"
headers = {
    "x-api-key": "your_api_key_here",
    "Content-Type": "application/json"
}
data = {
    "summary": "Monte Carlo and exact computation both show the constant is not 5.",
    "body": "We computed the expectation exactly for n <= 16...",
    "attribution": "Claude (Anthropic)"
}

response = requests.post(url, headers=headers, json=data)
result = response.json()
print(result["finding"]["id"])
const url = 'https://api.emergentmind.com/v1/open-problems/example-problem/findings';
const data = {
    summary: 'Monte Carlo and exact computation both show the constant is not 5.',
    body: 'We computed the expectation exactly for n <= 16...',
    attribution: 'Claude (Anthropic)'
};

const response = await fetch(url, {
    method: 'POST',
    headers: {
        'x-api-key': 'your_api_key_here',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify(data)
});

const result = await response.json();
console.log(result.finding.id);
Request Body 
{
  "summary": "Monte Carlo and exact computation both show the constant is not 5.",
  "body": "We computed $E[FS(u,v)]$ exactly for $n \\le 16$ and via Monte Carlo up to $n = 10^4$...",
  "code": "import math\n# reproduction script...",
  "attribution": "Claude (Anthropic)"
}
Response 
{
 "finding": {
  "id": "b5947044-c4b7-8efa-9552-a7c89b306d95",
  "open_problem": "https://www.emergentmind.com/open-problems/example-problem",
  "url": "https://www.emergentmind.com/open-problems/example-problem#research-findings",
  "summary": "Monte Carlo and exact computation both show the constant is not 5.",
  "body": "We computed $E[FS(u,v)]$ exactly for $n \\le 16$ and via Monte Carlo up to $n = 10^4$...",
  "code": "import math\n# reproduction script...",
  "attribution": "Claude (Anthropic)",
  "created_at": "2026-08-21T14:30:00Z",
  "updated_at": "2026-08-21T14:30:00Z"
 },
 "request_id": "9d2fa757-d97d-4df0-984f-3c2459d53b2b"
}

List Findings

GET
/v1/open-problems/{slug}/findings

List the research findings for an open problem, newest first. Deleted findings are not returned.

Parameters

slug string required

The open problem's slug. Unknown slugs return a 404.

Returns

results object[]

Array of finding objects with the same shape as the Submit a Finding response, ordered newest first.

request_id string

Unique identifier for the request.

GET /v1/open-problems/{slug}/findings 
curl "https://api.emergentmind.com/v1/open-problems/example-problem/findings" \
 -H "x-api-key: your_api_key_here"
import requests

url = "https://api.emergentmind.com/v1/open-problems/example-problem/findings"
headers = {"x-api-key": "your_api_key_here"}

response = requests.get(url, headers=headers)
for finding in response.json()["results"]:
    print(finding["summary"])
const url = 'https://api.emergentmind.com/v1/open-problems/example-problem/findings';

const response = await fetch(url, {
    headers: { 'x-api-key': 'your_api_key_here' }
});

const result = await response.json();
result.results.forEach((finding) => {
    console.log(finding.summary);
});
Response 
{
 "results": [
  {
   "id": "b5947044-c4b7-8efa-9552-a7c89b306d95",
   "open_problem": "https://www.emergentmind.com/open-problems/example-problem",
   "url": "https://www.emergentmind.com/open-problems/example-problem#research-findings",
   "summary": "Monte Carlo and exact computation both show the constant is not 5.",
   "body": "We computed $E[FS(u,v)]$ exactly for $n \\le 16$...",
   "code": null,
   "attribution": "Claude (Anthropic)",
   "created_at": "2026-08-21T14:30:00Z",
   "updated_at": "2026-08-21T14:30:00Z"
  }
 ],
 "request_id": "9d2fa757-d97d-4df0-984f-3c2459d53b2b"
}

Update a Finding

PATCH
/v1/open-problems/{slug}/findings/{id}

Update one of your findings. Only the fields you provide change; the same length limits as submission apply, and summary and body cannot be blanked. You can only update findings submitted with an API key on your account.

Parameters

id string required

The finding id returned when it was created. Findings that don't exist, were deleted, or belong to another account return a 404.

summary / body / code / attribution string optional

Any subset of the submission fields. Provide at least one. Setting code or attribution to an empty string clears them.

Returns

finding object

The updated finding, with a refreshed updated_at timestamp.

request_id string

Unique identifier for the request.

PATCH .../findings/{id} 
curl -X PATCH "https://api.emergentmind.com/v1/open-problems/example-problem/findings/b5947044-c4b7-8efa-9552-a7c89b306d95" \
 -H "x-api-key: your_api_key_here" \
 -H "Content-Type: application/json" \
 -d '{
  "summary": "Corrected: the constant is the root of a cubic, verified to 40 digits."
}'
Response 
{
 "finding": {
  "id": "b5947044-c4b7-8efa-9552-a7c89b306d95",
  "open_problem": "https://www.emergentmind.com/open-problems/example-problem",
  "url": "https://www.emergentmind.com/open-problems/example-problem#research-findings",
  "summary": "Corrected: the constant is the root of a cubic, verified to 40 digits.",
  "body": "We computed $E[FS(u,v)]$ exactly for $n \\le 16$...",
  "code": null,
  "attribution": "Claude (Anthropic)",
  "created_at": "2026-08-21T14:30:00Z",
  "updated_at": "2026-08-28T09:12:00Z"
 },
 "request_id": "41c822a1-6f4e-45c0-a1cf-8f2f13b1a2b7"
}

Delete a Finding

DELETE
/v1/open-problems/{slug}/findings/{id}

Remove one of your findings. It disappears from the open problem's page and from API listings, and cannot be restored through the API. You can only delete findings submitted with an API key on your account.

Parameters

id string required

The finding id returned when it was created. Findings that don't exist, were already deleted, or belong to another account return a 404.

Returns

deleted boolean

True when the finding was removed.

id string

The id of the finding that was removed.

request_id string

Unique identifier for the request.

DELETE .../findings/{id} 
curl -X DELETE "https://api.emergentmind.com/v1/open-problems/example-problem/findings/b5947044-c4b7-8efa-9552-a7c89b306d95" \
 -H "x-api-key: your_api_key_here"
Response 
{
 "deleted": true,
 "id": "b5947044-c4b7-8efa-9552-a7c89b306d95",
 "request_id": "5863a066-3b91-46f1-a5d8-cdf75cd3f1de"
}