Knowledge your AI agent can actually afford to read.

Every time your agent looks something up, it pays for about 15,000 tokens of markup to recover roughly 500 tokens of fact. You are billed for all of it — the navigation, the citation scaffolding, the edit links — and then your model throws it away. Wikexa did that reading already. You get the facts.

51M+
records, parsed and ready to read
5–12 ms
warm response at the edge
~30×
fewer tokens than fetching the page
Free
for individuals and open projects
What's in it

Fifty-one million records. Five corpora. One interface.

Twenty-seven million academic papers with abstracts, citations and DOIs. The complete English Wikipedia — every article, section and infobox parsed. Structured entity data with dates, identifiers and relationships. A dictionary spanning thousands of languages. Quotations, textbooks, travel guides and course material beside them. Every one of them parsed ahead of time and stored as JSON, so a request is a read rather than a scrape — and 6.2 million are full-text searchable.

27M+
academic papers — abstracts, citations, DOIs (CC0)
10.2M
entity records — dates, identifiers, relationships
8.15M
dictionary entries across thousands of languages
4.76M
encyclopedia articles, sections and infoboxes parsed
How it works

One call. Structured facts. Done.

Reference sites have APIs, but they were built to render pages — they return markup, navigation chrome and citation scaffolding. An agent pays for all of it in tokens and discards nearly all of it. Wikexa does that parsing once, ahead of time, and stores the answer.

1

Ask by name

Send whatever the user said. Apple, Apple Inc and Q312 all resolve to one entity through redirects and our alias index.

2

Get only the facts

Infobox as key–value pairs, a ~200-token summary, categories, related entities, and normalised claims. No markup, no empty fields.

3

Pull more if you need it

article() returns sections as a JSON array and accepts sections and max_chars, so a long page never floods your context.

# Ask GET /v1/lookup?entity=Tim%20Cook # Facts come back { "title": "Tim Cook", "wikidata_id": "Q265852", "description": "American business executive", "summary": "Timothy Donald Cook is an…", "facts": { "employer": "Apple Inc.", "occupation": "business executive" }, "source_url": "https://en.wikipedia.org/…", "license": "CC BY-SA 4.0" }
The tools

Six calls cover almost everything.

Every tool is available over MCP and as a plain REST endpoint. Both surfaces run the same handler, so they cannot drift apart.

lookup(entity)

Facts and a short summary

Structured facts plus a ~200-token summary. Resolves aliases, redirects and entity IDs, so you can pass whatever the user typed.

article(title, sections?, max_chars?)

The whole page, structured

Sections as a JSON array with the infobox parsed out. Ask for one section by name, or cap the payload — the token dial is yours.

search(query, limit?)

When you don't know the title

Full-text relevance blended with monthly pageviews, so apple returns Apple Inc. and the fruit — not a disambiguation stub.

define(word, language?, pos?)

A real dictionary, not a guess

Etymology, pronunciation and senses by part of speech, across thousands of languages — so an agent can look a word up instead of inferring it.

papers(topic, query?, year?)

Academic research, structured

27M+ papers from OpenAlex — title, abstract, authors, citations and DOI. Browse by topic or search by keyword. CC0 metadata.

recent(topic?, hours?)

Newer than your training cutoff

Articles changed in the last hours or days — elections, appointments, releases, deaths. The freshness a static model cannot have.

The dictionary

Eight million words, in languages your model has barely read.

Ask a model what an Old English word means and it will answer confidently, because plausible morphology is easy to generate and hard to check. define() returns the actual entry — senses, part of speech, etymology, pronunciation — for 8.15 million words across thousands of languages, including historical ones and hundreds of regional and indigenous languages.

1

Every language at once

One spelling, every language that uses it. hund comes back in eleven — Old English, Old Norse, Gothic, Scots, Danish, Icelandic and more — each with its own senses.

2

Fields, not prose

Senses grouped by part of speech, with etymology and pronunciation as separate values. Nothing to scrape out of a rendered page.

3

Narrow it when you know

Pass language or pos and you get one entry instead of eleven. The full list still comes back, so the agent can pick.

# One word, eleven languages GET /v1/define?word=hund&language=Old%20English { "word": "hund", "languages": [{ "language": "Old English", "etymology": "from *hundą, from *ḱm̥tóm.", "parts_of_speech": [ { "pos": "Noun", "senses": [ { "definition": "dog" } ] }, { "pos": "Noun", "senses": [ { "definition": "hundred" } ] } ] }], "languages_available": [ "Alemannic German", "Danish", "Gothic", "Icelandic", "Middle English", "Scots", "Norwegian Bokmål", "Norwegian Nynorsk", "Old English", "Old Norse", "Old Saxon" ] }
What it saves

Thirty times less, for the same answer.

Ten thousand lookups a day is 150 million tokens of markup your model reads and discards. The same ten thousand answers here are closer to 5 million. At a dollar per million input tokens, that is $150 a day against $5 — and the invoice is the least of it.

Your context window is the real bill

Fifteen thousand tokens of HTML does not just cost money. It crowds out the reasoning you wanted the room for, and it is where truncation bugs are born. Facts arrive as facts, so the window stays yours.

Fast enough to sit inside the loop

Warm lookups come back in single-digit milliseconds, from anywhere. No cold start, no query to plan, no rate-limit dance. Your agent can ask three times over before one page fetch would have finished.

Free where it should be

Individuals, research and open-source projects use it at no cost, with no key and no account. Businesses running it at volume take a service plan that funds the infrastructure.

Built to be found by software.

MCP over streamable HTTP, an OpenAPI description, llms.txt, and the usual well-known discovery documents. Listed in the Model Context Protocol registry as com.wikexa/knowledge.

MCPJSON-RPC 2.0OpenAPI 3.1llms.txtREST
Integration guide
Try it

Nothing to sign up for.

curl -s 'https://wikexa.com/v1/lookup?entity=Ada%20Lovelace'

curl -s -X POST https://wikexa.com/mcp \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/call",
       "params":{"name":"lookup","arguments":{"entity":"Ada Lovelace"}}}'

Or point any MCP client at https://wikexa.com/mcp.