Verify citations programmatically.

Overview

Three ways to integrate citation verification.

CiteOrbit answers one question about a bibliographic reference: does a real published work match it? You send a single reference string, formatted or messy, and get back a verdict with the authoritative metadata (title, authors, year, DOI, venue, link) when a match exists.

The headline use case is anti-hallucination: a chatbot or writing tool verifies citations before showing them to users, catching fabricated references such as fake papers or real-looking DOIs attached to nothing. CiteOrbit flags references that can't be matched to any real record in Crossref or OpenAlex. Note the limits: uncertain verdicts exist by design, and a sloppily formatted real reference can come back not_found.

Quickstart

From zero to a verified reference in three steps.

https://app.citeorbit.com/api/v1
Authorization: Bearer cob_live_xxxxxxxxxxxxxxxx

curl -X POST https://app.citeorbit.com/api/v1/verify \
  -H "Authorization: Bearer $CITEORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"reference": "Kahneman, D. (2011). Thinking, Fast and Slow. Farrar, Straus and Giroux."}'

REST API v1

One endpoint: verify a single bibliographic reference, synchronously.

The /api/v1 path is a compatibility contract: response shapes will not change breakingly within v1, and breaking changes get /api/v2.

Verify a reference

Exactly one reference per call (no batch in v1), 1 to 2000 characters. Formatted or messy text both work.

POST /api/v1/verify
Authorization: Bearer cob_live_...
Content-Type: application/json

{ "reference": "Vaswani, A., Shazeer, N., et al. (2017). Attention is all you need. Advances in Neural Information Processing Systems, 30." }

{
  "code": "ok",
  "result": {
    "rawText": "Vaswani, A., Shazeer, N., et al. (2017). Attention is all you need. ...",
    "verdict": "verified",
    "confidence": 0.9,
    "matched": {
      "title": "Attention Is All You Need",
      "authors": ["Vaswani, A.", "Shazeer, N."],
      "year": "2017",
      "doi": "10.xxxx/xxxxx",
      "venue": "Advances in Neural Information Processing Systems",
      "url": "https://doi.org/10.xxxx/xxxxx"
    },
    "note": "Matched a record in Crossref. The metadata in \"matched\" is the authoritative version."
  }
}

Verdicts

A fabricated reference comes back like this:

{
  "code": "ok",
  "result": {
    "verdict": "not_found",
    "confidence": 0.8,
    "matched": null,
    "note": "No matching record found in Crossref or OpenAlex — the reference may be fabricated, or too obscure/new to verify. Do not present it as a real work without another source."
  }
}

Errors

Failures return the envelope with a machine code and a human-readable message.

Latency

Verification runs a full extraction and enrichment pipeline: a GROBID parse followed by Crossref, OpenAlex, Semantic Scholar and Google Scholar lookups. This is not an instant-autocomplete API.

• verified (clean match): roughly 4 to 7 seconds.
• not_found: roughly 17 to 20 seconds. This is the slow path, every fallback source is exhausted before giving up.
• Design your client with a 60 second timeout and a visible "checking…" state.

Rate limits and pricing

• 60 requests per minute per workspace (burst limit).
• Per-key usage caps: daily, weekly, or monthly, set on the key.
• Free during beta, fair-use limits apply. Published pricing is on the roadmap.

MCP server

Give your LLM the ability to verify citations before presenting them.

CiteOrbit is a remote MCP server: any MCP-capable client (Claude, ChatGPT desktop, IDEs, agent frameworks) can connect and let its model check that a cited work actually exists.

• Endpoint: https://app.citeorbit.com/api/mcp
• Transport: Streamable HTTP (the current MCP standard). Legacy SSE is intentionally not supported.
• Auth: the same API key, sent as Authorization: Bearer cob_live_...

The verify_reference tool

The server exposes exactly one tool. Input: reference (string, 10 to 2000 characters), one full bibliographic reference, formatted or messy. Output: the same JSON verdict object as the REST endpoint. Parity is a design guarantee, the MCP tool never exceeds what the REST API can do.

Connect a client

Claude Code:

claude mcp add --transport http citeorbit https://app.citeorbit.com/api/mcp \
  --header "Authorization: Bearer cob_live_..."

Generic MCP client config:

{
  "mcpServers": {
    "citeorbit": {
      "type": "http",
      "url": "https://app.citeorbit.com/api/mcp",
      "headers": { "Authorization": "Bearer cob_live_..." }
    }
  }
}

Raw JSON-RPC sanity check:

curl -X POST https://app.citeorbit.com/api/mcp \
  -H "Authorization: Bearer $CITEORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json, text/event-stream" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

What's coming

On the roadmap for the public API.

OJS integration

For journals: no-code checks inside your editorial workflow.

Running Open Journal Systems? Install the CiteOrbit plugin and editors get one-click Validate with CiteOrbit actions on the References tab and on manuscript files: the report opens straight from OJS. The integration uses its own queued, batch-based API under /api/ojs/*, separate from API v1.

Install the plugin

OJS API: scopes

Authenticate every request with Authorization: Bearer <key>. Keys are workspace-scoped and carry one or both permissions:

Check references

Send up to 100 raw citation strings (for example, the references a manuscript system already has on file). The check runs asynchronously and returns a report_id you can poll or link to. Checks spend credits from the workspace the API key belongs to.

# verify three references
curl -X POST https://app.citeorbit.com/api/ojs/reference-checks \
  -H "Authorization: Bearer cob_live_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "article_title": "On the verification of citations",
    "citation_style": "apa-7",
    "references": [
      { "position": 1, "raw": "Smith, J. (2021). A study of things. Journal of Things, 4(2), 11-20." },
      { "position": 2, "raw": "Doe, A. (2019). Another paper. Press." }
    ]
  }'

{
  "code": "queued",
  "report_id": "chk_a1b2c3",
  "message": "References sent to CiteOrbit."
}

Check a file

Multipart upload. Accepts DOCX, DOC, or ODT (PDF is not supported for file checks).

curl -X POST https://app.citeorbit.com/api/ojs/file-checks \
  -H "Authorization: Bearer cob_live_xxxxxxxxxxxxxxxx" \
  -F "file=@manuscript.docx" \
  -F "citation_style=apa-7" \
  -F "journal_abbreviation=J. Things"

Get a check's result

Poll until status is completed.

{
  "status": "completed",
  "score": 92,
  "summary": {
    "total": 24,
    "verified": 22,
    "issues": 2
  }
}

OJS API: limits

• Per-key cap: each key has a configurable daily, weekly, or monthly check limit.
• Rate limit: bursts are throttled per workspace; throttled calls return rate_limited with a Retry-After header.
• Expiry: keys can be given an expiry date and revoked anytime.
• Max 100 references per reference check.

OJS API: error codes

These apply to /api/ojs/* endpoints only (API v1 errors are documented above).

Support

We are happy to help you integrate.

To request API access during the beta, or for any question about the API, MCP server, or OJS plugin, email support@citeorbit.com or open an issue on the plugin's GitHub repository. For workspace, billing and credit questions, see your account dashboard.