Pull citations from a paper
A bibliography is a list only a citation manager can really use, and retyping fifty references by hand is where careful research turns tedious. This endpoint reads a paper's reference list and returns each citation as structured JSON — authors, title, year, publication, identifiers where present — ready to import instead of retype.
Run it online
Run this on our servers with your account. Free tools run in your browser; this one bills your KIT balance per the price above.
The gap between a printed reference list and usable data
A reference list formatted for a reader's eye — hanging indents, italicized journal names, an inconsistent mix of comma and period depending on the citation style — carries no machine-readable structure at all. Copying it into a reference manager one entry at a time is slow and error-prone, especially across the several citation styles a single literature review might touch: APA in one source paper, Vancouver numbering in another, an author-date variant in a third.
Who actually deals with reference lists at volume
Researchers assembling a systematic review who need every cited source from dozens of papers loaded into one library, journal production staff checking that in-text citations match the bibliography before typesetting, academic librarians building citation databases from digitized older journals, and reference-management tool builders who need a reliable way to import a bibliography a user pastes in as a scanned or exported page.
How the request and result flow
Send the paper or the reference-list pages to POST /ocr/citation and get a task_id back immediately, since the job runs asynchronously rather than holding a connection open. When extraction completes, the parsed citation list — each entry broken into author, title, year, source and any identifier the source included — arrives by signed webhook or sits at a signed link for 24 hours.
Citation styles are a young convention on an old habit
Scholars have cited earlier work for centuries, but the standardized citation style — APA, MLA, Chicago, Vancouver and the rest — is a twentieth-century invention meant to make references machine-comparable long before machines could read them. This endpoint closes that loop: it reads whichever style a paper actually used and normalizes the result into one consistent schema, regardless of which convention the original author followed.
Where it plugs into a review pipeline
At $0.003 per request plus $0.0135 per page, and billed only for successful extractions, a systematic-review tool can run every included paper's bibliography through this endpoint as it's added to the review, building a deduplicated citation library automatically rather than asking a research assistant to transcribe reference lists between screening rounds. Failed jobs retry automatically up to three times at no charge, and the endpoint requires prepaid balance — no free tier, by design, to keep it fast.
What you can do with it
Systematic review citation libraries
A research team extracts every reference from dozens of included papers to build one deduplicated citation library instead of transcribing each bibliography.
Journal production QA
Production staff pull the parsed reference list to cross-check that every in-text citation has a matching bibliography entry before typesetting.
Reference manager import
A reference-management app lets a user paste in a scanned or copied bibliography and imports each citation as a structured record automatically.
Digitizing older journal archives
A library extracts citations from scanned back issues to populate a searchable citation database that never existed in digital form.
FAQ
What does the Citation Extraction API return?
A structured JSON list of the paper's references, each broken into author, title, year, source publication and any identifier present in the original entry.
How do I call the citation extraction api?
Send the file to POST /ocr/citation, receive a task_id immediately, and get the parsed citations by webhook or a signed link once the async task finishes.
Does it support APA, MLA, Vancouver and other citation styles?
Yes, it reads whichever style the paper actually uses and normalizes every entry into the same structured schema regardless of formatting convention.
Is there a free tier for extracting bibliographic citations?
There's no free tier — free tiers get abused and slow everyone down. Access runs on a prepaid ForHosting KIT balance: top up from $10.00 (it never expires) and each request is charged at its published price, so a call with no balance returns HTTP 402. No subscription, no tokens, no invented credits, and a failed task is never charged.
How much does citation extraction cost?
$0.003 per request plus $0.0135 per page, published and flat, billed only when extraction succeeds.
Can it process a scanned bibliography from an older journal?
Yes, it extracts text from scanned pages as well as native digital PDFs before parsing the reference list.
Am I charged for a failed extraction?
No. Failed tasks retry automatically up to three times and are never billed; you get a clear error if all retries fail.
Can I extract citations from many papers in bulk?
Submit one request per paper; each returns its own task_id, so a full literature review's worth of papers can be processed concurrently.
For developers — API access
Everything on this page is available programmatically. This section is for teams who want to wire it into their own systems; everyone else can just use the tool above.
API endpoint
Prefer to automate it? One authenticated POST creates the task; the result comes back by webhook or a signed link. The same capability also runs here on the web, and soon from our app, email and Telegram.
Call it from your stack
curl -X POST https://api.kit.forhosting.com/ocr/citation \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"input":"…"}'const res = await fetch("https://api.kit.forhosting.com/ocr/citation", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"input": "…"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/ocr/citation",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"input": "…"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/ocr/citation", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"input":"…"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"input":"…"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/ocr/citation", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Example request
{
"input": "…"
}Example response
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "ocr.citation",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}The API is asynchronous: the call returns a task_id immediately and the result arrives by webhook. Polling is capped at 1 req/s per task.
Pricing
Published price — no tokens, no invented credits. A failed task is never charged.
Limits
max_mb | 25 |
max_pages | 10 |
Errors
| HTTP | Code | Meaning |
|---|---|---|
401 | unauthorized | Missing or invalid API key. |
402 | insufficient_balance | Your balance doesn't cover the task price. |
404 | unknown_type | That task type doesn't exist. |
429 | rate_limited | Too many requests. Use the webhook instead of polling. |
413 | input_too_large | The file exceeds the size limit. |
422 | task_failed | The task failed after 3 retries. You are never charged for it. |