canonical: https://jentic.com/apis/developer.oxforddictionaries.com/oxford-dictionaries

# Oxford Dictionaries API

Jentic publishes the only available OpenAPI specification for the Oxford Dictionaries API, keeping it validated and agent-ready. The Oxford Dictionaries API gives access to Oxford's lexical data - definitions, lemmas, inflections, synonyms, translations, sentences, and pronunciations - alongside utility endpoints that describe supported languages, lexical categories, registers, domains, and grammatical features. The 24 endpoints are read-only GETs and span both the sandbox and live hosts; production calls require app_id and app_key headers issued from the Oxford Dictionaries developer portal.

## For AI agents

Look up word definitions, lemmas, inflections, synonyms, translations, and pronunciations across many languages through 24 Oxford Dictionaries endpoints.

## Scope

Does not perform full-sentence machine translation, run grammar correction, or write to the dictionary - use for read-only lexical lookup, search, and reference data only.

## Capabilities

- Get definitions and senses for a headword via GET `/entries/{source_lang}/{word_id}`
- Find the dictionary headword (lemma) for any inflected form via GET `/lemmas/{source_lang}/{word_id}`
- List inflected forms of a word via GET `/inflections/{source_lang}/{word_id}`
- Search the dictionary by prefix or fuzzy match via GET `/search/{source_lang}` and `/search/thesaurus/{source_lang}`
- Translate a word from one language to another via GET `/translations/{source_lang}/{target_lang}/{word_id}`
- Pull synonyms, antonyms, sentences, and pronunciations via `/thesaurus/{source_lang}/{word_id}`, `/sentences/{source_lang}/{word_id}`, and `/pronunciations/{source_lang}/{word_id}`
- Discover supported languages, lexical categories, registers, domains, and grammatical features via /languages, /lexicalCategories, /registers, /domains, /grammaticalFeatures

## Use cases

### Lexical lookup in a learning app

Language-learning and reading apps can call `/entries/{source_lang}/{word_id}` for definitions, `/pronunciations/{source_lang}/{word_id}` for audio cues, and `/sentences/{source_lang}/{word_id}` for usage examples on tap. The /lemmas endpoint resolves any inflected form (e.g., 'running' to 'run') so the app can look up the canonical entry. Together these give a rich lexical experience without licensing your own dictionary corpus.

Example prompt: GET `/lemmas/en/running`, take the headword, then GET `/entries/en/run` to render the definition and senses in the app.

### Translation and synonym pipelines

Editorial and localisation pipelines can call `/translations/{source_lang}/{target_lang}/{word_id}` for word-level translations and `/thesaurus/{source_lang}/{word_id}` for in-language synonyms. The `/search/translations` endpoint helps when the source word is not yet known to be a headword. This is suitable for in-context word-replacement features inside writing tools and CMSs.

Example prompt: GET `/translations/en/es/innovate` to surface Spanish translations for a writing tool's tooltip.

### Inflection and morphology research

Researchers and grammar-checking tools can use `/inflections/{source_lang}/{word_id}` and `/grammaticalFeatures/{source_lang}` to inspect how Oxford categorises a word's morphology. `/lexicalCategories/{source_lang}` surfaces the supported parts of speech, and /registers and /domains expose Oxford's stylistic and topical classifications. The metadata endpoints let a tool stay aligned with Oxford's taxonomy as it evolves.

Example prompt: GET `/inflections/en/be` to retrieve am, is, are, was, were, been for a grammar-checking rule.

### Agent-driven dictionary tools

An AI assistant in a writing tool can answer 'define this word', 'give me a synonym', or 'translate this word to Spanish' by routing through the Oxford Dictionaries API via Jentic. Jentic returns the right operation schema and adds the app_id and app_key headers from the vault at execution, so the user's Oxford keys never enter the agent's context.

Example prompt: Through Jentic, search 'define a word in English', load the `/entries/{source_lang}/{word_id}` operation, and execute with source_lang=en and the word the user selected.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/entries/{source_lang}/{word_id}` | Get definitions and senses |
| GET | `/lemmas/{source_lang}/{word_id}` | Get the headword for an inflected form |
| GET | `/inflections/{source_lang}/{word_id}` | List inflections of a word |
| GET | `/thesaurus/{source_lang}/{word_id}` | Get synonyms and antonyms |
| GET | `/translations/{source_lang}/{target_lang}/{word_id}` | Translate a word into a target language |
| GET | `/sentences/{source_lang}/{word_id}` | Get example sentences |
| GET | `/search/{source_lang}` | Prefix and fuzzy search the dictionary |
| GET | `/languages` | List supported languages and dictionary pairs |

## Key resources

- **Entries** — Definitions, senses, and detailed lexical data via `/entries/{source_lang}/{word_id}.`
- **Lemmas and Inflections** — Resolve headwords and inflected forms via /lemmas and /inflections.
- **Thesaurus** — Synonyms and antonyms via `/thesaurus/{source_lang}/{word_id}` and `/search/thesaurus/{source_lang}.`
- **Translations** — Word-level translation via `/translations/{source_lang}/{target_lang}/{word_id}` and `/search/translations.`
- **Search** — Prefix and fuzzy search via `/search/{source_lang}` and `/words/{source_lang}.`
- **Sentences and Pronunciations** — Example sentences and audio pronunciations via /sentences and /pronunciations.
- **Metadata** — Languages, lexical categories, registers, domains, and grammatical features metadata endpoints.

## Why Jentic

- **Setup:** Wiring the Oxford Dictionaries API by hand means sending both the app_id and app_key headers, choosing the sandbox or production host, and threading the source_lang and word_id path parameters yourself. Through Jentic you install once, import the Oxford Dictionaries API from the API Directory, store the app_id and app_key once, and your agent calls it.
- **Permission scoping:** You choose which Oxford operations the agent may call, so you can limit it to the ones it needs, such as entry lookup and translation, and leave the others out. Every operation is read-only lexical lookup, so the agent cannot write to the dictionary or run grammar correction.
- **Credential handling:** Your Oxford app_id and app_key are stored once, encrypted, by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'define a word' or 'translate a word', and Jentic returns the matching Oxford operation with its source_lang and word_id parameters so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Merriam-Webster Dictionary API** — American English dictionary, thesaurus, and learner's data.
- **NewsAPI.org** — News articles for usage-in-context examples.
- **Google Cloud Translation** — Machine translation across 100+ languages.

## FAQ

### Why is there no official OpenAPI spec for the Oxford Dictionaries API?

Oxford publishes documentation at developer.oxforddictionaries.com but does not publish a single OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call the Oxford Dictionaries API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Oxford Dictionaries API use?

Production calls require app_id and app_key headers, both issued from the Oxford Dictionaries developer portal. The sandbox host (od-api-sandbox.oxforddictionaries.com) accepts the same credentials with reduced data. Through Jentic the app_id and app_key are stored in the vault and added to the request headers at execution, so the raw keys never reach the agent.

### Can I look up a definition for any inflected form?

Yes, but in two steps. First call GET `/lemmas/{source_lang}/{word_id}` to resolve the headword for the inflected form, then GET `/entries/{source_lang}/{word_id}` with that headword to get the definition. Calling /entries directly with an inflected form will often return no match.

### What languages and translations does the API support?

Call GET /languages to list supported source languages and translation pairs at runtime - the supported set varies by Oxford subscription. Use `/translations/{source_lang}/{target_lang}/{word_id}` for word-level translation and `/search/translations/{source_lang}/{target_lang}` when the source word may need fuzzy resolution.

### What are the rate limits for the Oxford Dictionaries API?

The OpenAPI spec does not declare rate limits. Oxford applies per-plan monthly request quotas and a per-second request rate visible on the developer dashboard. Treat HTTP 429 as a signal to back off and consult your dashboard for the limits attached to your plan.

### How do I get example sentences for a word through Jentic?

Through Jentic, search 'get example sentences for a word', load the `/sentences/{source_lang}/{word_id}` operation, and execute with source_lang=en and the resolved headword. Jentic injects the app_id and app_key headers from the vault.

### Can I limit what my agent is allowed to do with the Oxford Dictionaries API?

Yes. Jentic One is self-hosted, so you run it and your own rules decide which Oxford operations and credentials the agent may use. You can allow just the endpoints it needs, such as entry lookup via GET `/entries/{source_lang}/{word_id}` and translation via GET `/translations/{source_lang}/{target_lang}/{word_id}`, and leave the rest out. Every Oxford operation is a read-only GET, so the agent cannot write to the dictionary or run grammar correction.