# Get Assistant Task Source: https://scite.mintlify.app/api-reference/assistant/get-assistant-task /openapi.json get /api_partner/assistant/tasks/{task_id} Poll the status and results of an assistant task. Call this endpoint repeatedly until the status is `SUCCESS`. ## Task States | Status | Description | |--------|-------------| | `PENDING` | Task is queued, not yet started | | `STARTED` | Task is actively processing — `info` contains progress details | | `SUCCESS` | Task completed — `result` contains the full response | | `FAILURE` | Task failed — `error` contains the error message | | `CANCELLED` | Task was cancelled via the cancel endpoint | | `REVOKED` | Task was revoked | ## Progress Info (during `STARTED`) While the task is running, the `info` field provides real-time progress: ```json { "id": "abc123", "status": "STARTED", "info": { "step": "EXECUTING_SEARCHES", "stepNumber": 3, "response": "partial response text...", "searches": ["query 1", "query 2"], "publicationsUsed": ["10.1234/example"], "publicationsConsulting": ["Author et al., Title, Journal, 2024"], "currentSearch": "current query being executed" } } ``` **Processing steps in order:** 1. `SCHEDULING_ASSISTANT` — task queued 2. `GENERATING_SEARCH_STRATEGY` — AI generating search queries 3. `EXECUTING_SEARCHES` — running queries against Elasticsearch 4. `RETRIEVING_UPLOADED_DOCUMENTS` — loading reference check documents (if applicable) 5. `RETRIEVING_PRIMARY_SOURCES` — enriching with primary source data 6. `COMPOSING_RESPONSE` — preparing context for LLM 7. `GENERATING_RESPONSE` — LLM generating the answer ## Success Result ```json { "id": "abc123", "status": "SUCCESS", "result": { "title": "How does protein structure affect function?", "sessionId": 42, "slug": "how-does-protein-structure-affect-function-xK9mP", "turns": [...], "lastUpdated": "2025-01-15", "createdAt": "2025-01-15", "tooManySessions": false } } ``` ## Turn Structure Each assistant turn in the `turns` array contains: | Field | Type | Description | |-------|------|-------------| | `role` | str | `"user"` or `"assistant"` | | `content` | str | Response text with numbered citation markers like `[1]`, `[2]` | | `structuredResponse` | list or null | Structured response data (when `useStructuredResponse` was true) | | `references` | list | Cited references (see below) | | `searchStrategy` | list[str] or null | Search queries that were used | | `warning` | str or null | Warning message if applicable | | `model` | str or null | The model that generated this response | | `settings` | dict or null | Settings applied (e.g., AI-suggested `rankBy`, `yearFrom`, `yearTo`) | | `publicationsConsulted` | list[dict] or null | All publications considered (including unused ones) | ## Reference Structure Each reference in the `references` array: | Field | Type | Description | |-------|------|-------------| | `answer` | str | The relevant text passage (citation statement or abstract excerpt) | | `texts` | list[str] | Text passages used | | `context` | str | Surrounding context of the passage | | `title` | str | Paper title | | `doi` | str | Paper DOI | | `link` | str | Link to the Scite report page | | `type` | str | `"abstract"` or `"citation_statement"` | | `paper` | object | Full paper metadata (title, authors, journal, year, date, abstract, tally, DOI, etc.) | | `patent` | object or null | Patent data if from patent search | | `refCheckId` | str or null | Reference check task ID if from uploaded document | # Start an Assistant query Source: https://scite.mintlify.app/api-reference/assistant/start-an-assistant-query /openapi.json post /api_partner/assistant/poll Submit a question to the Scite Assistant. Returns a task ID that you poll via `GET /api_partner/assistant/tasks/{task_id}`. ## Required Fields ### `turns` — Conversation History The conversation history as a list of turn objects. Each turn has a `role` (`"user"` or `"assistant"`) and `content`. For a new conversation, provide a single user turn: ```json { "turns": [{"role": "user", "content": "How does protein structure affect function?"}] } ``` For multi-turn conversations, include the full history. Assistant turns should include `references`, `searchStrategy`, `model`, `settings`, and `publicationsConsulted` from previous responses. ### `userInput` — Current Question The current user question (should match the last user turn's content). Used independently for search strategy generation and tool selection. --- ## Reference Behavior Control | Field | Type | Default | Description | |-------|------|---------|-------------| | `alwaysUseReferences` | bool | false | Force reference retrieval even for non-scientific questions | | `neverUseReferences` | bool | false | Skip reference retrieval entirely (takes precedence over `alwaysUseReferences`) | | `numReferences` | int | 25 | Maximum reference passages to include in LLM context | | `referenceChecks` | list[str] | [] | Celery task IDs from uploaded documents (reference check feature) | | `searches` | list[str] | [] | Pre-defined search queries (skips auto-generation) | --- ## Search Filtering | Field | Type | Default | Description | |-------|------|---------|-------------| | `yearFrom` / `yearTo` | str or null | null | Filter by date range (4-digit year or ISO date) | | `topics` | list[str] | [] | Filter by research topics | | `citationSections` | list[str] | [] | Filter citations by paper section: `results`, `discussion`, `conclusion`, `methods`, `introduction` | | `publicationTypes` | list[str] | [] | Filter by type: `review`, `systematic review`, `meta-analysis`, `practice guideline`, `journal-article`, etc. | | `journals` | list[str] | [] | Filter to specific journal names | | `openAccessOnly` | bool | false | Only return open access publications | | `abstractsOnly` | bool | false | Only use paper abstracts (excludes citation statements) | | `fullTextsOnly` | bool | false | Only use citation statements (excludes abstracts) | --- ## Paper Selection | Field | Type | Default | Description | |-------|------|---------|-------------| | `dois` | list[str] | [] | Specific DOIs to scope the search to. DOIs in `userInput` are auto-extracted and merged. | | `dashboards` | list[int] | [] | Collection (dashboard) IDs to pull DOIs from. Requires authenticated user with access. | --- ## Result Ranking — `rankBy` Controls how retrieved results are ranked before being passed to the LLM. Default: `"all"`. | Value | Ranking Strategy | |-------|-----------------| | `all` | Balanced: relevance + total citations + Scite index + date + supporting + contrasting | | `relevance` | Semantic relevance only | | `date` | Recency + relevance | | `citations` | Total citation count + relevance | | `supporting-citations` | Supporting citation count + relevance | | `contrasting-citations` | Contrasting citation count + relevance | | `journal-rank` | Scite journal index + relevance | --- ## Response Configuration | Field | Type | Default | Description | |-------|------|---------|-------------| | `answerLength` | str | `"short"` | `"short"` (~100-200 words), `"medium"` (comprehensive), or `"long"` (exhaustive) | | `model` | str or null | `gpt-5-nano-2025-08-07` | LLM model for response generation (see below) | | `reasoningEffort` | str or null | null | `"minimal"`, `"low"`, `"medium"`, or `"high"` — only for reasoning models | ### Available Models | Model ID | Provider | Notes | |----------|----------|-------| | `claude-sonnet-4-6` | Anthropic | 200K context, 64K max output | | `claude-opus-4-6` | Anthropic | 200K context, 128K max output | | `claude-sonnet-4-5-20250929` | Anthropic | 200K context, 64K max output | | `claude-opus-4-5-20251101` | Anthropic | 200K context, 64K max output | | `claude-haiku-4-5-20251001` | Anthropic | 200K context, 64K max output | | `gpt-5-nano-2025-08-07` | OpenAI | **Default.** 400K context. Reasoning model | | `gpt-5-mini-2025-08-07` | OpenAI | 400K context. Reasoning model | | `gpt-5.2-2025-12-11` | OpenAI | 400K context. Reasoning model. Supports `reasoningEffort` | If one provider fails, the system automatically falls back to the other. Unsupported or retired model strings automatically fall back to the default (`gpt-5-nano-2025-08-07`). --- ## Structured Response Mode | Field | Type | Default | Description | |-------|------|---------|-------------| | `useStructuredResponse` | bool | false | Return per-reference structured data instead of prose | | `jsonResponseType` | str or null | null | `null` (full detail), `"concise"`, or `"boolean"` (yes/no screening) | | `reprocessTurnIdx` | int or null | null | Index of an existing turn to reprocess | | `columnSlug` | str or null | null | Slug of a specific column to reprocess | --- ## Patent Modes | Field | Type | Default | Description | |-------|------|---------|-------------| | `usePatentMode` | bool | false | Search patents only (no academic papers) | | `useMixedPatentMode` | bool | false | Search both patents and academic papers | --- ## Session Management | Field | Type | Default | Description | |-------|------|---------|-------------| | `sessionId` | int or null | null | Existing session ID to continue a conversation | --- ## Response Returns `{"id": ""}`. If the user is rate-limited, also includes `"usage": {"used": N, "max": M}`. --- ## Examples **Basic single question:** ```json { "turns": [{"role": "user", "content": "What is the effect of exercise on depression?"}], "userInput": "What is the effect of exercise on depression?" } ``` **DOI-scoped question:** ```json { "turns": [{"role": "user", "content": "Summarize the key findings"}], "userInput": "Summarize the key findings", "dois": ["10.1002/cepa.3344", "10.1002/hsr2.70931"] } ``` **Filtered search:** ```json { "turns": [{"role": "user", "content": "What do systematic reviews say about mindfulness for anxiety?"}], "userInput": "What do systematic reviews say about mindfulness for anxiety?", "publicationTypes": ["systematic review", "meta-analysis"], "yearFrom": "2020", "rankBy": "supporting-citations", "answerLength": "long" } ``` **Structured response (table mode):** ```json { "turns": [{"role": "user", "content": "Does each paper support the hypothesis that X causes Y?"}], "userInput": "Does each paper support the hypothesis that X causes Y?", "useStructuredResponse": true, "jsonResponseType": "boolean", "dois": ["10.1234/a", "10.1234/b", "10.1234/c"] } ``` # Retrieve aggregated citation statistics for an author. Source: https://scite.mintlify.app/api-reference/authors/retrieve-aggregated-citation-statistics-for-an-author /openapi.json get /authors/{author_slug}/stats Retrieve aggregated citation statistics for an author without fetching all papers. Returns: - `tally`: How this author's papers are cited by others (supporting, contrasting, mentioning counts) - `citingTally`: How this author's papers cite other works (supporting, contrasting, mentioning counts) - `totalPapers`: Total number of papers by this author This endpoint performs the aggregation server-side, eliminating the need for clients to fetch all papers in chunks and aggregate locally. # Retrieve author metadata and papers by author slug. Source: https://scite.mintlify.app/api-reference/authors/retrieve-author-metadata-and-papers-by-author-slug /openapi.json get /authors/{author_slug}/papers Retrieve author metadata and papers by author slug. Note that these endpoints require an API token for usage. ### Author Slug Format ### A valid author slug from the Scite database. Examples of valid author slugs: d-hirsch-gLmJld ### Offset & Limit for Paper Pagination ### - `offset`: The number of papers to skip before starting to collect the result set. Default is 0. - `limit`: The maximum number of papers to return. A next page URL will be provided if there are more papers available. # Create a collection from a list of DOIs or a search query Source: https://scite.mintlify.app/api-reference/collections/create-a-collection-from-a-list-of-dois-or-a-search-query /openapi.json post /api_partner/collections/create Either 'dois' or 'query' is required to create a dashboard. If both are provided, 'query' will be used. # Delete a collection by slug Source: https://scite.mintlify.app/api-reference/collections/delete-a-collection-by-slug /openapi.json delete /api_partner/collections/{collection_slug} # Get a collection by slug Source: https://scite.mintlify.app/api-reference/collections/get-a-collection-by-slug /openapi.json get /api_partner/collections/{collection_slug} # Update a collection by slug Source: https://scite.mintlify.app/api-reference/collections/update-a-collection-by-slug /openapi.json put /api_partner/collections/{collection_slug} Only DOI collections can be updated via this endpoint. Use `/create` for search query based collections. # Get 510(k) summary PDF detail Source: https://scite.mintlify.app/api-reference/evidence/get-510k-summary-pdf-detail /openapi.json get /api_partner/evidence/device510k-summaries/{item_id} # Get 510(k) summary PDFs facets Source: https://scite.mintlify.app/api-reference/evidence/get-510k-summary-pdfs-facets /openapi.json post /api_partner/evidence/device510k-summaries/facets # Get 510(k) summary PDFs schema Source: https://scite.mintlify.app/api-reference/evidence/get-510k-summary-pdfs-schema /openapi.json get /api_partner/evidence/device510k-summaries/schema # Get clinical trial detail Source: https://scite.mintlify.app/api-reference/evidence/get-clinical-trial-detail /openapi.json get /api_partner/evidence/clinical-trials/{trial_id} # Get clinical trials facets Source: https://scite.mintlify.app/api-reference/evidence/get-clinical-trials-facets /openapi.json post /api_partner/evidence/clinical-trials/facets # Get clinical trials schema Source: https://scite.mintlify.app/api-reference/evidence/get-clinical-trials-schema /openapi.json get /api_partner/evidence/clinical-trials/schema Returns all queryable and facetable fields for the clinical trials dataset. # Get device 510(k) detail Source: https://scite.mintlify.app/api-reference/evidence/get-device-510k-detail /openapi.json get /api_partner/evidence/device510k/{device_id} # Get device 510(k) facets Source: https://scite.mintlify.app/api-reference/evidence/get-device-510k-facets /openapi.json post /api_partner/evidence/device510k/facets # Get device 510(k) schema Source: https://scite.mintlify.app/api-reference/evidence/get-device-510k-schema /openapi.json get /api_partner/evidence/device510k/schema Returns all queryable and facetable fields for the device 510(k) dataset. # Get drug detail Source: https://scite.mintlify.app/api-reference/evidence/get-drug-detail /openapi.json get /api_partner/evidence/drugs/{drug_id} # Get drugs facets Source: https://scite.mintlify.app/api-reference/evidence/get-drugs-facets /openapi.json post /api_partner/evidence/drugs/facets # Get drugs schema Source: https://scite.mintlify.app/api-reference/evidence/get-drugs-schema /openapi.json get /api_partner/evidence/drugs/schema # Get FAERS facets Source: https://scite.mintlify.app/api-reference/evidence/get-faers-facets /openapi.json post /api_partner/evidence/faers/facets # Get FAERS report detail Source: https://scite.mintlify.app/api-reference/evidence/get-faers-report-detail /openapi.json get /api_partner/evidence/faers/{report_id} # Get FAERS schema Source: https://scite.mintlify.app/api-reference/evidence/get-faers-schema /openapi.json get /api_partner/evidence/faers/schema # Get grant detail Source: https://scite.mintlify.app/api-reference/evidence/get-grant-detail /openapi.json get /api_partner/evidence/grants/{grant_id} # Get grants facets Source: https://scite.mintlify.app/api-reference/evidence/get-grants-facets /openapi.json post /api_partner/evidence/grants/facets # Get grants schema Source: https://scite.mintlify.app/api-reference/evidence/get-grants-schema /openapi.json get /api_partner/evidence/grants/schema Returns all queryable and facetable fields for the grants dataset. # Get MAUDE facets Source: https://scite.mintlify.app/api-reference/evidence/get-maude-facets /openapi.json post /api_partner/evidence/maude/facets # Get MAUDE report detail Source: https://scite.mintlify.app/api-reference/evidence/get-maude-report-detail /openapi.json get /api_partner/evidence/maude/{report_id} # Get MAUDE schema Source: https://scite.mintlify.app/api-reference/evidence/get-maude-schema /openapi.json get /api_partner/evidence/maude/schema # Get MHRA alert detail Source: https://scite.mintlify.app/api-reference/evidence/get-mhra-alert-detail /openapi.json get /api_partner/evidence/mhra/{item_id} # Get MHRA facets Source: https://scite.mintlify.app/api-reference/evidence/get-mhra-facets /openapi.json post /api_partner/evidence/mhra/facets # Get MHRA schema Source: https://scite.mintlify.app/api-reference/evidence/get-mhra-schema /openapi.json get /api_partner/evidence/mhra/schema # Get patent detail Source: https://scite.mintlify.app/api-reference/evidence/get-patent-detail /openapi.json get /api_partner/evidence/patents/{patent_id} # Get patent facets Source: https://scite.mintlify.app/api-reference/evidence/get-patent-facets /openapi.json post /api_partner/evidence/patents/facets # Get patent schema Source: https://scite.mintlify.app/api-reference/evidence/get-patent-schema /openapi.json get /api_partner/evidence/patents/schema Returns all queryable and facetable fields for the patents dataset. # Search 510(k) summary PDFs Source: https://scite.mintlify.app/api-reference/evidence/search-510k-summary-pdfs /openapi.json get /api_partner/evidence/device510k-summaries # Search clinical trials Source: https://scite.mintlify.app/api-reference/evidence/search-clinical-trials /openapi.json get /api_partner/evidence/clinical-trials # Search device 510(k) clearances Source: https://scite.mintlify.app/api-reference/evidence/search-device-510k-clearances /openapi.json get /api_partner/evidence/device510k # Search FAERS drug adverse event reports Source: https://scite.mintlify.app/api-reference/evidence/search-faers-drug-adverse-event-reports /openapi.json get /api_partner/evidence/faers # Search FDA drug labels, Orange Book, and Drugs@FDA Source: https://scite.mintlify.app/api-reference/evidence/search-fda-drug-labels-orange-book-and-drugs@fda /openapi.json get /api_partner/evidence/drugs # Search grants Source: https://scite.mintlify.app/api-reference/evidence/search-grants /openapi.json get /api_partner/evidence/grants # Search MAUDE adverse event reports Source: https://scite.mintlify.app/api-reference/evidence/search-maude-adverse-event-reports /openapi.json get /api_partner/evidence/maude # Search MHRA alerts Source: https://scite.mintlify.app/api-reference/evidence/search-mhra-alerts /openapi.json get /api_partner/evidence/mhra # Search patents Source: https://scite.mintlify.app/api-reference/evidence/search-patents /openapi.json get /api_partner/evidence/patents # Get count of publications for a journal dashboard by slug/ISSN Source: https://scite.mintlify.app/api-reference/journal/get-count-of-publications-for-a-journal-dashboard-by-slugissn /openapi.json get /dashboards/journal/{slug_or_issn}/article-count Get count of publications for Scite journal dashboard by valid ISSN. # Get Issn Editorial Notices Source: https://scite.mintlify.app/api-reference/journal/get-issn-editorial-notices /openapi.json get /issn-editorial-notices Get multiple editorial notice aggregations for multiple ISSNs. Up to 500 ISSNs can be specified at once. # Get Scite journal index for ISSN Source: https://scite.mintlify.app/api-reference/journal/get-scite-journal-index-for-issn /openapi.json get /issn-sji Read the Scite Journal Index for a single ISSN. For example: https://api.scite.ai/issn-sji?issn=2232-9935. # Get Scite journal index for multiple ISSNs Source: https://scite.mintlify.app/api-reference/journal/get-scite-journal-index-for-multiple-issns /openapi.json post /issn-sji-bulk Get multiple Scite journal indices for multiple ISSNs. Up to 500 ISSNs can be specified at once. # Get Smart Citation tallies for a journal Source: https://scite.mintlify.app/api-reference/journal/get-smart-citation-tallies-for-a-journal /openapi.json get /journal/{issn}/tallies Get tally information for a journal given a valid ISSN. Requires API Key Response includes a tally of the number of supporting, mentioning, and contrasting citation statements received by publications from this journal. # Get yearly Scite index for a journal Source: https://scite.mintlify.app/api-reference/journal/get-yearly-scite-index-for-a-journal /openapi.json get /journal/{issn}/yearly-si Get Scite index information for a journal given its slug or a valid ISSN, and an optional list of years. If no year is specified, returns the various Scite index values for all years. To specify one year in the request, use the following format: `/journal/{issn}/yearly-si&years={YEAR_ONE}` To specify multiple years in the request, use the following format: `/journal/{issn}/yearly-si&years={YEAR_ONE}&years={YEAR_TWO}` Response includes a list of objects, each one containing the `twoYearSi`, `fiveYearSi`, `allYearSi` relative to the corresponding year. # Get recommended papers to read given a DOI Source: https://scite.mintlify.app/api-reference/paper-recommendations/get-recommended-papers-to-read-given-a-doi /openapi.json get /api_partner/recommend-papers/{doi} # Get multiple papers (bulk, GET with body — prefer POST) Source: https://scite.mintlify.app/api-reference/papers/get-multiple-papers-bulk-get-with-body-—-prefer-post /openapi.json get /papers Get multiple papers. Pass in a list of DOIs and receive a paper for each one. Up to 500 papers can be requested at once. # Get multiple papers (bulk, POST) Source: https://scite.mintlify.app/api-reference/papers/get-multiple-papers-bulk-post /openapi.json post /papers Get multiple papers. Pass in a list of DOIs and receive a paper for each one. Up to 500 papers can be requested at once. # Get Papers by Target Source: https://scite.mintlify.app/api-reference/papers/get-papers-by-target /openapi.json get /papers/sources/{target_doi} Get papers citing a given DOI. # Get Single Paper Source: https://scite.mintlify.app/api-reference/papers/get-single-paper /openapi.json get /papers/{doi} Get paper metadata for DOI. # Resolve PMID to DOI Source: https://scite.mintlify.app/api-reference/papers/resolve-pmid-to-doi /openapi.json get /papers/resolve-pmid/{pmid} Resolve a PubMed ID (PMID) to a DOI without requiring the paper to exist in the Scite database. # Cancel Task Source: https://scite.mintlify.app/api-reference/reference-check/cancel-task /openapi.json get /reference_check/tasks/{task_id}/cancel Cancel task that is scheduled/in progress. Once a task is successfully canceled its status will be `CANCELLED`. # Get Result Source: https://scite.mintlify.app/api-reference/reference-check/get-result /openapi.json get /reference_check/tasks/{task_id} Retrieve reference check job status. This allows both fetching the job result and polling for job completion. Whilst the job is in progress its status will be either `PENDING` or `STARTED`. Once the job is complete its status will be `SUCCESS` and the result can be read under the `result` key of this response. # Get Result Url Source: https://scite.mintlify.app/api-reference/reference-check/get-result-url /openapi.json get /reference_check/tasks/{task_id}/result_url Get URL for task result. # Post Reference Check Source: https://scite.mintlify.app/api-reference/reference-check/post-reference-check /openapi.json post /reference_check Schedule a document for processing. Can either supply a PDF or docx file directly as a `multipart/form-data` upload, or specify a URL where the file can be downloaded. # Retrieve distinct references from a publication Source: https://scite.mintlify.app/api-reference/references/retrieve-distinct-references-from-a-publication /openapi.json get /api_partner/references/references_from/{doi} Gets distinct references from a given DOI. Can also return relevant paper metadata and tallies for references. Note that this endpoint requires an API token for usage. # Retrieve distinct references to a publication Source: https://scite.mintlify.app/api-reference/references/retrieve-distinct-references-to-a-publication /openapi.json get /api_partner/references/references_to/{doi} Gets distinct references to a given DOI. Can also return relevant paper metadata and tallies for reference sources. Results can be filtered by a list of source_dois to limit output. Note that this endpoint requires an API token for usage. # Get search results from a query Source: https://scite.mintlify.app/api-reference/search/get-search-results-from-a-query /openapi.json get /api_partner/search # Receive citations with the DOI as a source paper Source: https://scite.mintlify.app/api-reference/smart-citation-graph/receive-citations-with-the-doi-as-a-source-paper /openapi.json get /api_partner/citations/cited_by/{doi} Get citations made from a given DOI. Note that the citation statements are excluded from the output. Can also return relevant paper metadata and tallies for citation sources. This endpoint requires an API token with special access. For more information, please contact us at sales@scite.ai # Receive citations with the DOI as a target paper Source: https://scite.mintlify.app/api-reference/smart-citation-graph/receive-citations-with-the-doi-as-a-target-paper /openapi.json get /api_partner/citations/citing/{doi} Get citations made toward a given DOI. Can also return relevant paper metadata and tallies for citation sources. Results can be filtered both by a list of source_dois and a list of to limit output. This endpoint requires an API token with special access. For more information, please contact us at sales@scite.ai # Get Aggregate Tally Source: https://scite.mintlify.app/api-reference/tallies/get-aggregate-tally /openapi.json post /tallies/aggregate Get the sum of multiple tallies by DOI. Up to 100 DOIs can be requested. # Get multiple tallies (bulk, GET with body — prefer POST) Source: https://scite.mintlify.app/api-reference/tallies/get-multiple-tallies-bulk-get-with-body-—-prefer-post /openapi.json get /tallies Get multiple smart citation tallies. Pass in a list of DOIs and receive a tally for each one. Up to 500 tallies can be requested at once. # Get multiple tallies (bulk, POST) Source: https://scite.mintlify.app/api-reference/tallies/get-multiple-tallies-bulk-post /openapi.json post /tallies Get multiple smart citation tallies. Pass in a list of DOIs and receive a tally for each one. Up to 500 tallies can be requested at once. # Get Section Tallies Source: https://scite.mintlify.app/api-reference/tallies/get-section-tallies /openapi.json post /tallies/cited-by-sections Get multiple section tallies. Pass in a list of DOIs and receive a tally for each one indicating how many times it was cited within various sections -- Intro, Methods, Results, Discussion, or Other. Up to 500 tallies can be requested at once. # Get Section Tally Source: https://scite.mintlify.app/api-reference/tallies/get-section-tally /openapi.json get /tallies/cited-by-sections/{doi} Get section tally for given DOI # Get Tally Source: https://scite.mintlify.app/api-reference/tallies/get-tally /openapi.json get /tallies/{doi} Get smart citation tally for given DOI. # Authentication Source: https://scite.mintlify.app/authentication Self-service API keys are available on the Pro plan. Enterprise plans get issued credentials via sales. Most Scite endpoints require an `Authorization` header. ``` Authorization: Bearer ``` ```bash theme={null} curl -H 'Authorization: Bearer ' 'https://api.scite.ai/tallies/aggregate' ``` ## Which plan do I need? On Pro, create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). ## Self-service API keys (Pro plan) If you're on the Pro plan, create and manage your own API keys from the [API Console](https://scite.ai/users/me/api). No need to contact sales. * Keys are shown once at creation, and can be revoked or regenerated instantly. * Keys can optionally be set to expire. * Each key carries a set of **scopes** that determine which endpoints it can call. When creating a key you choose from three presets: * **Read**: all read scopes your account is entitled to (search, citation graph, journals, and any others your plan or license grants). * **Read + Write**: the read scopes plus write access (e.g. managing collections). * **Fine-grained**: pick exactly the scopes you need. * You can only grant a key the scopes your own account is entitled to; requesting a scope you don't have is rejected. * Search snippets are always redacted on self-service keys. ### What's included on a base Pro key Not every endpoint is covered by the default Read / Read + Write presets. Some require a specific scope that has to be added to your account first. | Feature | Included on a base Pro key? | | ---------------------------------------- | ----------------------------------------------------------------------------- | | Tallies, Papers, Journal/ISSN lookups | Yes | | Search | Yes, but see the [licensing note](/guides/search) for commercial/research use | | Collections | Usually, contact sales if you get a `403` | | Assistant | No, requires the `assistant` scope, [email sales](mailto:sales@scite.ai) | | Reference Check | No, requires a paid license, [email sales](mailto:sales@scite.ai) | | Evidence (patents, grants, trials, etc.) | No, requires a per-dataset scope, [email sales](mailto:sales@scite.ai) | If a call fails with `403 User not authorized` and your key otherwise works, this is almost always why, check with sales rather than assuming your key is broken. ## Enterprise access Enterprise customers can be issued `client_id` / `client_secret` credentials for server-to-server integrations, higher rate limits, and additional scopes. [Contact sales](https://scite.ai/contact) to discuss Enterprise access. **Step 1: exchange your credentials for a bearer token** ```bash theme={null} curl -X POST 'https://api.scite.ai/auth_token_users/token' \ -H 'Content-Type: application/json' \ -d '{ "client_id": "", "client_secret": "", "grant_type": "client_credentials" }' ``` Response: ```json theme={null} { "access_token": "eyJhbG...", "token_type": "bearer", "expire_in": 1711234567 } ``` The access token expires after 2 hours. Request a new one when it expires. ## Rate limiting Authenticated requests can access restricted endpoints and get higher rate limits than the shared default. Every response includes rate limit headers you can check programmatically rather than counting requests yourself: ``` RateLimit-Limit: 60 RateLimit-Remaining: 59 RateLimit-Reset: 19 X-RateLimit-Limit-Minute: 60 X-RateLimit-Remaining-Minute: 59 ``` ## MCP API authentication The MCP API (see the [MCP overview](/mcp/overview)) supports two authentication options: * **OAuth 2.1 (interactive)**: for browser-based MCP clients such as Claude Desktop or ChatGPT. Requires a Scite premium subscription. See [Scite.ai/mcp](https://scite.ai/mcp) for client setup instructions. * **API key (programmatic)**: create a self-service API key on the **Pro plan**, grant it the `mcp` scope, and send it as a bearer token to `/mcp`. Enterprise customers can alternatively exchange `client_id`/`client_secret` credentials as shown above. Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). # Changelog Source: https://scite.mintlify.app/changelog Notable changes to the Scite API and these docs. **API keys can now be self-provisioned on the Pro plan.** Previously all tokens required contacting sales. Now you can create, rotate, and revoke your own key instantly from the [API Console](https://scite.ai/users/me/api). Enterprise plans (issued `client_id`/`client_secret`, higher limits, additional scopes) still go through [sales](https://scite.ai/contact). See [Authentication](/authentication) for details. # Citations & Tallies Source: https://scite.mintlify.app/concepts/citation-model How Scite models citations: targets, sources, Smart Citations, and tallies. Scite's data model differs from a plain citation count in a few ways that matter once you start building against the API. ## Target and source * **Target**: the publication being cited. * **Source**: the publication making the citation. Endpoints are named from this perspective: `citing/{doi}` returns sources that cite the target `{doi}`; `cited_by/{doi}` returns targets cited by the source `{doi}`. ## Smart Citations A **Smart Citation** is a citation statement classified by how it uses the target publication: | Classification | Meaning | | --------------- | ---------------------------------------------------------------------------------------------------- | | `supporting` | The citing statement supports the target's findings | | `contradicting` | The citing statement contradicts the target's findings (referred to as "contrasted" in the Scite UI) | | `mentioning` | The citing statement mentions the target without a clear supporting/contradicting stance | | `unclassified` | Not yet classified | ## Tallies vs. citing publications This is the distinction that trips people up most: * **Tally counts** (`total`, `supporting`, `contradicting`, `mentioning`, `unclassified`) count individual **citation statements** that Scite has extracted and classified as Smart Citations. * **`citingPublications`** counts distinct **publications** that cite the target, drawn from the broader citation graph rather than only publications with a classified Smart Citation. These come from different underlying counts, so neither bounds the other. `citingPublications` can exceed `total` (not every citing publication has a classified statement) or fall below it (one publication can make several classified statements toward the same target). Treat them as two different measurements, not a count and a subset. ## References vs. citations In everyday language "citation" and "reference" are interchangeable. In the Scite API, **references** specifically means the distinct source/target DOI pairs. See the References endpoints (**References** in the API Reference tab) if you need the raw pairs rather than tally counts. ## Related * [Smart Citations guide](/guides/smart-citations): the endpoints that implement this model * [Glossary](/concepts/glossary): quick lookup for other terms (dashboards, DOI resolution, etc.) # Glossary Source: https://scite.mintlify.app/concepts/glossary Quick reference for Scite-specific terminology used across the API. | Term | Meaning | | ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Target** | The publication being cited. See [Citations & Tallies](/concepts/citation-model). | | **Source** | The publication making the citation. | | **Tally** | Counts of citation statements toward a target: `total`, `supporting`, `contradicting`, `mentioning`, `unclassified`. | | **Smart Citation** | A citation statement classified by how it uses the target (supporting / contradicting / mentioning). | | **Contradicting / Contrasted** | The same concept: the API uses `contradicting`, the Scite UI displays "contrasted." | | **Citing publications** | The count of distinct publications citing a target: not the same as the tally `total` (see [Citations & Tallies](/concepts/citation-model)). | | **Papers** | Publication metadata: DOI, title, publication date, and related fields. | | **Collection** | A set of papers monitored over time. Created from DOIs or a search query via the API or MCP, or in the Scite UI (which also imports from Zotero, Mendeley, or CSV). | | **Dashboard** | A report on a collection. | | **Reference Check** | Scite's capability for evaluating and linking the references of a submitted document. | | **Scite Journal Index (SJI)** | A journal-level index derived from Scite's citation data, looked up by ISSN. | | **Assistant** | Scite's Q\&A endpoint that returns answers backed by citation evidence. | | **Evidence** | Non-citation regulatory and research records searchable alongside citation data: patents, grants, clinical trials, and FDA/MHRA regulatory records. | # Assistant Source: https://scite.mintlify.app/guides/assistant Ask research questions and get answers backed by citation evidence. The Assistant API answers research questions using Scite's citation evidence to ground its responses. Like Reference Check, it's a poll-based flow: submit a query, then poll for the result. Both endpoints require a key with the `assistant` scope, it isn't included by default on a self-service Pro key. If you get a `403`, [email sales](mailto:sales@scite.ai) to get the scope added, then generate a new key from the [API Console](https://scite.ai/users/me/api). ## 1. Start a query ```bash theme={null} curl 'https://api.scite.ai/api_partner/assistant/poll' \ -H 'Accept: application/json' \ -H 'Content-Type: application/json' \ -H 'Authorization: Bearer ' \ --data-raw '{ "turns": [{"role": "user", "content": "How does the structure of a protein affect its function?"}], "user_input": "How does the structure of a protein affect its function?", "numReferences": 25, "answerLength": "medium", "citationStyle": "ieee" }' ``` For a single-turn question, `turns` needs only one object. Multi-turn conversations add more objects to the `turns` array. The response is `{ "id": task_id }`. ## 2. Poll for the result ```bash theme={null} curl 'https://api.scite.ai/api_partner/assistant/tasks/{task_id}' \ -H 'Authorization: Bearer ' ``` Poll until `status` is `SUCCESS`. While pending, the response's `info` field includes the currently generated content, search strategies, and search results so far, useful for streaming a "thinking" state to users. ## Useful parameters | Parameter | Purpose | | -------------------------------------------- | -------------------------------------------------------------------------- | | `alwaysUseReferences` / `neverUseReferences` | Force or suppress citation-backed answers | | `abstractsOnly` / `fullTextsOnly` | Restrict the evidence pool | | `yearFrom` / `yearTo` | Limit evidence by publication year | | `topics`, `journals`, `publicationTypes` | Scope the evidence pool | | `useStructuredResponse` | Enable **tables mode**: returns structured tabular output instead of prose | | `rankBy` | Controls result ranking: see below | ### `rankBy` values * `all`: a combination of the factors below (default) * `relevance`: relevance to the query * `date`: most recent first * `citations`: by citation count * `supporting-citations` / `contrasting-citations`: by supporting or contradicting citation count * `journal-rank`: by journal rank/impact ## Related * [Reference Check guide](/guides/reference-check): the same poll pattern, for evaluating a document's references instead of answering a question # Collections Source: https://scite.mintlify.app/guides/collections Create collections of papers and monitor how their citations develop over time. A **collection** is a set of papers you monitor over time. Collections alert you to new supporting or contrasting citations, flag retractions, and give you a living view of how a research area is developing. Use them to track your own publications, monitor another group's output, or stay on top of a field. A **dashboard** is a report on a collection. Create collections from a list of DOIs or a search query through this API, via [MCP](/mcp/overview), or in the Scite UI, which also imports from Zotero, Mendeley, or a CSV of DOIs. A collection created anywhere is available everywhere: use it as context in the UI, the API, or MCP. On Pro, create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). ## Working with collections ```bash theme={null} curl -X POST 'https://api.scite.ai/api_partner/collections/create' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{"name": "My Review", "dois": ["10.1038/nature12373", "10.1126/science.1157784"]}' ``` If both `dois` and `query` are provided, `query` takes precedence. | Endpoint | Purpose | | --------------------------------------------------- | ---------------------------------------- | | `POST /api_partner/collections/create` | Create a collection from DOIs or a query | | `GET /api_partner/collections/{collection_slug}` | Fetch a collection by slug | | `PUT /api_partner/collections/{collection_slug}` | Update a collection | | `DELETE /api_partner/collections/{collection_slug}` | Delete a collection | Collection write operations (create/update/delete) require an API key with **write** scope; see [Authentication](/authentication#self-service-api-keys-pro-plan). If you get a `403 User not authorized` on a Collections call even with a valid key, your account may not have Collections access enabled. [Email sales](mailto:sales@scite.ai) to check. ## Related * [Search guide](/guides/search): the `query` you can pass into a collection is the same search syntax * [Papers & Authors guide](/guides/papers-and-authors): look up the publications inside a collection by DOI # Evidence Source: https://scite.mintlify.app/guides/evidence Search patents, grants, clinical trials, and regulatory records alongside citation data. The Evidence API searches non-citation research and regulatory records: patents, grants, clinical trials, FDA device/drug records, and adverse-event and safety-alert databases, sourced from Resolute's evidence datasets. Every resource below follows the **same four-endpoint pattern**, so once you've used one, you've used them all. Evidence isn't included in a standard self-service Pro key. Each dataset requires its own scope (`evidence:patents:api`, `evidence:grants:api`, `evidence:clinical-trials:api`, and equivalents for the other datasets). [Email sales](mailto:sales@scite.ai) to get a dataset scope added to your account, then generate a new key from the [API Console](https://scite.ai/users/me/api) so it picks up the scope. ## The pattern For a resource `{resource}` (e.g. `patents`): | Endpoint | Purpose | | ---------------------------------------------- | ------------------------------------------------------------------------------- | | `GET /api_partner/evidence/{resource}` | Search | | `GET /api_partner/evidence/{resource}/schema` | Get the filterable fields and their types for this resource | | `POST /api_partner/evidence/{resource}/facets` | Get facet counts (e.g. how many results per year) without fetching full results | | `GET /api_partner/evidence/{resource}/{id}` | Get a single record by its ID | Search takes two parameters, and they work differently than the [Search API](/guides/search): * **`q`**: free-text query. Supports `AND`, `OR`, `NOT`, and phrase matching with double quotes: `q=CRISPR`, `q="gene therapy" AND cancer`. * **`f`**: field filters, space-delimited, in `field:"value"` format (values must be double-quoted). Call the resource's `schema` endpoint to see which fields are filterable. ```bash theme={null} curl 'https://api.scite.ai/api_partner/evidence/patents/schema' \ -H 'Authorization: Bearer ' ``` ```bash theme={null} curl -G 'https://api.scite.ai/api_partner/evidence/patents' \ -H 'Authorization: Bearer ' \ --data-urlencode 'q=CRISPR' \ --data-urlencode 'f=patents.assignees.name:"Acme Corp" patents.filingStatus:"grant"' ``` Common filter fields by resource: | Resource | Example filters | | --------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Patents | `patents.filingStatus` (`"application"`, `"grant"`), `patents.assignees.name`, `patents.inventors.name`, `patents.languages` (ISO 639-1) | | Clinical trials | `trialState.phase` (`"Phase I"`..`"Phase IV"`, `"N/A"`), `trialState.overallStatus` (`"Recruiting"`, `"Completed"`, ...), `conditions`, `interventions.name`, `sponsors.name`, `registry`, `design.studyType` | | Grants | `agency`, `organization`, `piName`, `country` (ISO 3166-1 alpha-3), `dataSource` (`"NIH RePORTER"`, `"NSF"`, ...) | Date range filters use `gte`/`lt` suffixes with no space before the suffix: `f=dates.startDategte:"2024-01-01" dates.startDatelt:"2025-01-01"`. ISO dates, epoch milliseconds, and timezone offsets are all accepted; dates without a timezone are treated as UTC. Sorting uses `s` (default `_relevance`; call `schema` for sortable fields per resource) and `sortDir`, not the `sort`/`sort_order` names from Search. Pagination uses `p` (page number), not `limit`/`offset`. Some fields in search and detail responses are either a plain string or an object shaped like `{"id": "...", "name": "...", "highlighted": "..."}`, depending on the query. Handle both, e.g. `value.id ?? value.name ?? value`. ## Available resources | Resource | Path segment | Source data | | -------------------------- | ---------------------- | ---------------------------------------- | | Patents | `patents` | Patent filings | | Grants | `grants` | Research grant records | | Clinical trials | `clinical-trials` | Registered clinical trials | | Device clearances | `device510k` | FDA 510(k) device clearances | | Device clearance summaries | `device510k-summaries` | FDA 510(k) summary PDFs | | MHRA alerts | `mhra` | UK MHRA safety alerts | | MAUDE reports | `maude` | FDA adverse event reports (devices) | | FAERS reports | `faers` | FDA adverse event reports (drugs) | | Drugs | `drugs` | FDA drug labels, Orange Book, Drugs\@FDA | ## Related * [Search guide](/guides/search): the equivalent search over publications, with a different query syntax than Evidence * Full parameter reference: see **Evidence** in the API Reference tab; per-resource filters are best discovered via each resource's `/schema` endpoint # Papers & Authors Source: https://scite.mintlify.app/guides/papers-and-authors Look up publication metadata by DOI or PMID, and author-level metadata and citation statistics. These endpoints resolve a DOI or PMID to full metadata: title, abstract, authors with affiliations, journal, retraction status, and editorial notices. Pair with [tallies](/guides/smart-citations) for citation data. On Pro, create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). ## Get a single paper ```bash theme={null} curl 'https://api.scite.ai/papers/10.1038/nature12373' \ -H 'Authorization: Bearer ' ``` ## Get multiple papers ```bash theme={null} curl -X POST 'https://api.scite.ai/papers' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{"dois": ["10.1038/nature12373", "10.1126/science.1157784"]}' ``` Up to 500 DOIs per request. A GET variant also exists for compatibility; prefer POST for larger lists. ## Resolve a PMID to a DOI ```bash theme={null} curl 'https://api.scite.ai/papers/resolve-pmid/23851394' \ -H 'Authorization: Bearer ' ``` ## Get papers citing a target ```bash theme={null} curl 'https://api.scite.ai/papers/sources/10.1038/nature12373' \ -H 'Authorization: Bearer ' ``` ## Author metadata Look up an author's publications and aggregated citation statistics by author slug: ```bash theme={null} curl 'https://api.scite.ai/authors/georg-kucsko-mvlovd/papers' \ -H 'Authorization: Bearer ' ``` | Endpoint | Purpose | | ----------------------------------- | --------------------------------------------- | | `GET /authors/{author_slug}/papers` | Author metadata and papers | | `GET /authors/{author_slug}/stats` | Aggregated citation statistics for the author | `author_slug` isn't something you construct from a name, it's a Scite-generated identifier (name plus a random suffix, e.g. `georg-kucsko-mvlovd`). Get it from the `authorSlug` field on author objects returned by [paper lookups](#get-a-single-paper) or [search](/guides/search) results. An unrecognized slug returns `404 {"detail": "Slug not found"}`. ## Related * [Smart Citations guide](/guides/smart-citations): get tallies once you have a DOI * Recommendations: `GET /api_partner/recommend-papers/{doi}` (see **Paper recommendations** in the API Reference tab) suggests related papers given a DOI # Reference Check Source: https://scite.mintlify.app/guides/reference-check Submit a document and have its references evaluated and linked using Scite's data. Reference Check takes a document (PDF or DOCX), extracts its references, and evaluates each one against Scite's citation data, surfacing retracted, contradicted, or otherwise flagged sources cited in the document. This is an asynchronous, poll-based flow. Reference Check requires a paid license, it isn't included in a standard self-service Pro key. [Email sales](mailto:sales@scite.ai) to get access, then generate a new key from the [API Console](https://scite.ai/users/me/api) once it's enabled on your account. ## 1. Submit the document You can either upload the file directly or point to a URL: ```bash theme={null} # Upload directly curl -X POST 'https://api.scite.ai/reference_check' \ -H 'Authorization: Bearer ' \ -F 'file=@paper.pdf' ``` ```bash theme={null} # Or reference a URL curl -X POST 'https://api.scite.ai/reference_check' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{"url": "https://example.com/paper.pdf"}' ``` The response contains a task ID: ```json theme={null} { "id": "task_123" } ``` ## 2. Poll for the result ```bash theme={null} curl 'https://api.scite.ai/reference_check/tasks/task_123' \ -H 'Authorization: Bearer ' ``` Poll until the task status is no longer pending. The response includes the current state and, once complete, the evaluated references. An unrecognized or mistyped `task_id` doesn't return a 404, it returns `200 {"status": "PENDING"}` just like a real in-progress task. Hold onto the exact ID from the submit response rather than reconstructing it, or you can end up polling a task that will never complete. ## Other task operations | Endpoint | Purpose | | ------------------------------------------------- | ------------------------------------------------------------- | | `GET /reference_check/tasks/{task_id}/cancel` | Cancel a running task | | `GET /reference_check/tasks/{task_id}/result_url` | Get a direct URL to the result, instead of the inline payload | ## Related * [Assistant guide](/guides/assistant): a similar poll-based flow for Q\&A instead of reference evaluation # Search Source: https://scite.mintlify.app/guides/search Query Scite's publication metadata and citation data with Boolean terms and 25+ filters. Search covers publication metadata (topic, title, author, journal, date) and the content of citation statements, including where in the citing paper each statement occurs. Filters include retraction status, citation type counts, and 25+ other signals, so it works for screening papers as well as finding them. On Pro, create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). Commercial or research use of Search requires a separate license agreement, it isn't covered by individual plans. [Email sales](mailto:sales@scite.ai) before relying on Search for anything beyond evaluation. ## Basic search ```bash theme={null} curl -G 'https://api.scite.ai/api_partner/search' \ -H 'Authorization: Bearer ' \ --data-urlencode 'term="machine learning" AND healthcare' \ --data-urlencode 'limit=5' \ --data-urlencode 'sort=date' \ --data-urlencode 'sort_order=desc' ``` `term` supports Boolean operators (`AND`, `OR`, `NOT`) and phrase search (`"exact phrase"`). ## Filtering results Beyond `term`, the search endpoint accepts filters across three categories: `title`, `abstract`, `author` / `authors`, `journal` / `journals`, `publisher`, `paper_type` / `paper_types`, `affiliation` / `affiliations`, `topic` / `topics`, `date_from`, `date_to`, `doi` / `dois` `has_tally`, `has_retraction`, `has_concern`, `has_correction`, `has_erratum`, `has_withdrawn`, `citation_types`, `supporting_from` / `supporting_to`, `mentioning_from` / `mentioning_to`, `contrasting_from` / `contrasting_to`, `citing_publications_from` / `citing_publications_to` `substances` (PubChem canonical name), `mesh_type` (PubMed MeSH descriptor/qualifier), `section` / `sections` (where in the paper the citation occurs) Scope a search to specific publications with `doi` (single) or `dois` (multiple). Combine with `term` to search within those publications only. ## Sorting Use `sort` to control result order: | Value | Behavior | | ----------- | ------------------------------------- | | `relevance` | Default when a `term` is provided | | `date` | Most recent first (with `sort_order`) | | `citations` | By citation count | Combine with `sort_order` (`asc`/`desc`). ## Pagination Use `limit` (up to 10,000 per request) and `offset` together to page through results. ## Aggregations Set `compute_aggregations=true` and pass `aggregations` to get facet counts (e.g. by journal or year) alongside your results, useful for building filter UIs without a second round-trip. Search snippets are always redacted on self-service (Pro plan) API keys. Full snippet access requires an Enterprise agreement. [Contact sales](https://scite.ai/contact). ## Response shape Results come back as `{ count, countIsApproximate, aggregations, hits, suggestedTerm, restrictedCites }`. Each item in `hits` is a full paper object, including a `tally` field with the same shape as the [tallies endpoints](/guides/smart-citations) when one has already been computed for that paper (`null` otherwise), so you often don't need a separate tally call for search results you're already displaying. ## Related * Full parameter reference: see **Search** in the API Reference tab for every filter with types and examples * [Citations & Tallies](/concepts/citation-model): what `has_tally`, `supporting_from`, etc. actually measure # Smart Citations Source: https://scite.mintlify.app/guides/smart-citations Get tallies, browse the citation graph, and look up journal-level Smart Citation data. A citation count says a paper was cited 400 times. A Smart Citation tally says how many of those citations support the finding, contradict it, or mention it. These endpoints return that breakdown for any DOI, the citing papers behind it, and the section where each statement appears. See [Citations & Tallies](/concepts/citation-model) for the difference between a tally count and a citing-publications count. On Pro, create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). ## Get a tally for one DOI ```bash theme={null} curl 'https://api.scite.ai/tallies/10.1038/nature12373' \ -H 'Authorization: Bearer ' ``` ## Get tallies for many DOIs ```bash theme={null} curl -X POST 'https://api.scite.ai/tallies' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{"dois": ["10.1038/nature12373", "10.1126/science.1157784"]}' ``` Up to 500 DOIs per request. A GET variant of this endpoint also exists for compatibility, but POST is recommended for larger DOI lists. ## Tallies by section Citations occurring in the Introduction carry different weight than citations in the Discussion. `GET /tallies/cited-by-sections/{doi}` (and the bulk `POST /tallies/cited-by-sections`) breaks the tally down by the section of the citing paper where the statement appears. ## Browsing the citation graph Rather than a tally, you can retrieve the actual citing/cited publications: | Endpoint | Returns | | --------------------------------------------------- | ------------------------------------------- | | `GET /api_partner/citations/citing/{doi}` | Sources that cite this DOI as a target | | `GET /api_partner/citations/cited_by/{doi}` | Targets cited by this DOI as a source | | `GET /api_partner/references/references_to/{doi}` | Distinct references *to* this publication | | `GET /api_partner/references/references_from/{doi}` | Distinct references *from* this publication | ## Journal-level data * `GET /journal/{issn}/tallies`: Smart Citation tallies aggregated for an entire journal * `GET /journal/{issn}/yearly-si`: the Scite Journal Index (SJI) broken down by year * `GET /issn-sji` / `POST /issn-sji-bulk`: look up the Scite Journal Index for one or many ISSNs Journal-level tallies use different field names than DOI-level tallies: `totalCites`, `totalSupportingCites`, `totalContrastingCites`, `totalMentioningCites`, and `totalUnclassifiedCites`, rather than `total`, `supporting`, `contradicting`, `mentioning`, and `unclassified`. Don't assume the two shapes match. ## Related * [Search guide](/guides/search): filter by tally signals like `has_tally` or `supporting_from` * [Citations & Tallies](/concepts/citation-model): the underlying data model # Documentation Source: https://scite.mintlify.app/introduction The Scite API gives you tools to search, analyze, and evaluate scientific literature. Get access to 1.6B+ Smart Citations across 315M+ indexed articles, drawn from 41M+ full-text sources. With a Pro plan you can create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). ## What you can do Find papers by topic, author, journal, citation content, or 25+ other filters. See how many citing papers support, contradict, or mention any publication. Save sets of papers. Retrieve author publication lists and citation statistics. Screen a manuscript's reference list for retracted or contradicted sources. Search patents, grants, clinical trials, and FDA/MHRA regulatory records. Ask research questions and get cited answers. ## Use Scite in your AI tools Connect Scite to Claude, ChatGPT, or any MCP client to search the literature and retrieve citation data in conversation. See the [MCP API](/mcp/overview). ## Getting started On Pro, [create an API key instantly](/authentication) from the API Console. For Enterprise, [contact sales](https://scite.ai/contact). The [Quickstart](/quickstart) goes from API key to searching papers and checking a tally. Task-oriented guides live under **Guides**. The full endpoint reference is under **API Reference**. ## Key concepts Scite uses a few terms (target/source, tallies, dashboards) that don't map 1:1 onto other citation databases. Start with [Citations & Tallies](/concepts/citation-model) and the [Glossary](/concepts/glossary). # Scite MCP Source: https://scite.mintlify.app/mcp/overview Use Scite inside Claude, ChatGPT, and other AI tools: search the literature and pull citation stats without leaving the conversation. The MCP API connects Scite to Claude, ChatGPT, Cursor, and any other client that supports the [Model Context Protocol](https://modelcontextprotocol.io/). A connected assistant can search the literature and retrieve citation data on specific papers in conversation. Two ways in: * **Connect an AI app** (Claude Desktop, ChatGPT). No code. Client-specific setup at [scite.ai/mcp](https://scite.ai/mcp). * **Call the MCP endpoint directly** from a script or your own tool, using an API key. On Pro, create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). ## Authentication ### Option 1: Connect an AI app (OAuth) Browser-based MCP clients (Claude Desktop, ChatGPT) use the standard OAuth 2.1 authorization-code flow with PKCE. Sign in with your Scite account when prompted. A Scite premium subscription is required. Per-client setup at [scite.ai/mcp](https://scite.ai/mcp). Every request to `/mcp/oauth/authorize` must include `client_id`, `code_challenge`, and `code_challenge_method=S256`. A `client_id` is obtained via Dynamic Client Registration (DCR); clients discover the registration endpoint from `/.well-known/oauth-authorization-server`. Some platforms (e.g. Microsoft Copilot Studio) default to PKCE and DCR turned **off**. With those disabled, the authorize request omits required parameters and the server returns `invalid_request`. Enable **PKCE** and **DCR-with-discovery** (or supply a registered `client_id`) when configuring such a client. ### Option 2: API key (programmatic) For scripts, servers, or your own tool: create an API key on Pro from the [API Console](https://scite.ai/users/me/api), grant it the `mcp` scope, and send it as a bearer token to `/mcp`. No token exchange needed. It shares your account's MCP quota and billing. Enterprise customers can alternatively use issued `client_id`/`client_secret` credentials; see [Authentication](/authentication#enterprise-access). ## Endpoints | Method | Path | Description | | ------ | ------------- | ------------------------------------ | | GET | `/mcp/info` | Server info and capabilities | | POST | `/mcp` | JSON-RPC 2.0 endpoint for tool calls | | GET | `/mcp/health` | Health check | ## Methods | Method | Description | | ------------ | ------------------------------------------------ | | `initialize` | Returns protocol version and server capabilities | | `tools/list` | Lists available tools and their schemas | | `tools/call` | Execute a tool (e.g. `search_literature`) | | `ping` | Heartbeat check | ## Example: search literature ```bash theme={null} curl -X POST 'https://api.scite.ai/mcp' \ -H 'Authorization: Bearer ' \ -H 'Content-Type: application/json' \ -d '{ "jsonrpc": "2.0", "id": "1", "method": "tools/call", "params": { "name": "search_literature", "arguments": { "term": "\"machine learning\" AND healthcare", "limit": 5, "sort": "date", "sort_order": "desc" } } }' ``` `search_literature` supports Boolean operators, phrase search, and the same 25+ filters as the [Search API](/guides/search). Call `tools/list` to see its full input schema. # Quickstart Source: https://scite.mintlify.app/quickstart Search for papers and check a citation tally. The two most common calls: search for papers on a topic, then check how a specific paper has been cited. With a Pro plan, create an API key instantly from the [API Console](https://scite.ai/users/me/api). Need higher limits or managed credentials? Enterprise plans support custom usage and access requirements. [Contact sales](https://scite.ai/contact). See [Authentication](/authentication) for the full comparison. `term` supports `AND`, `OR`, `NOT`, and quoted phrases. ```bash theme={null} curl -G 'https://api.scite.ai/api_partner/search' \ -H 'Authorization: Bearer ' \ --data-urlencode 'term="machine learning" AND healthcare' \ --data-urlencode 'limit=5' \ --data-urlencode 'sort=date' \ --data-urlencode 'sort_order=desc' ``` The response includes a total `count` and a `hits` array. Each hit carries DOI, title, authors, journal, abstract, and citation tally where available. The [Search guide](/guides/search) covers the 25+ filters. Take a DOI from the results, or any DOI: ```bash theme={null} curl 'https://api.scite.ai/tallies/10.1038/nature12373' \ -H 'Authorization: Bearer ' ``` ```json theme={null} { "doi": "10.1038/nature12373", "total": 42, "supporting": 30, "contradicting": 2, "mentioning": 10, "unclassified": 0, "citingPublications": 38 } ``` 30 citation statements support this paper's findings, 2 contradict them, 10 mention it without taking a stance. `total` counts citation statements; `citingPublications` counts distinct papers. See [Citations & Tallies](/concepts/citation-model) for why those differ. * Use Scite inside Claude or ChatGPT: [MCP API](/mcp/overview) * Full paper metadata for any DOI: [Papers & Authors](/guides/papers-and-authors) * Tallies for up to 500 DOIs at once: [Smart Citations](/guides/smart-citations) * Screen a manuscript's reference list: [Reference Check](/guides/reference-check)