canonical: https://jentic.com/apis/api.lexicala.com/lexicala

# Lexicala Dictionary API

Jentic publishes the only available OpenAPI specification for Lexicala Dictionary API, keeping it validated and agent-ready. Lexicala is a multilingual lexical database that powers headword search, full entry retrieval, and free-text definition lookups across dozens of languages. Agents can list available languages and resources, search for entries by lemma, fetch a complete entry or sense by ID, run definition-text searches, retrieve RDF/JSON-LD output for semantic web pipelines, and pull a randomly selected entry. The API is distributed via RapidAPI, so calls authenticate against a RapidAPI subscription key.

## For AI agents

Look up dictionary entries, senses, and definitions across many languages - and retrieve RDF/JSON-LD for semantic web pipelines.

## Scope

Does not handle translation between languages, grammar correction, or text generation - use for dictionary lookup, definition search, and entry retrieval only.

## Capabilities

- List the languages and lexical resources available on the Lexicala platform
- Search for headwords (lemmas) by spelling across one or more language resources
- Retrieve a complete dictionary entry by ID, including senses, examples, and translations
- Fetch a single sense by ID for fine-grained semantic lookups
- Run free-text search across definition text to find entries that mention a phrase
- Return search results as RDF/JSON-LD for downstream knowledge graph use
- Retrieve a randomly selected entry for daily-word features

## Use cases

### Dictionary Lookups in Language-Learning Apps

Power in-app dictionary lookups in language-learning products. GET /search returns headword matches across the requested language resource; the client then fetches a full entry with `/entries/{entry_id}` to render definitions, senses, and examples. Caching the entry payload locally keeps repeat lookups fast and reduces API consumption.

Example prompt: Call GET /search with text='manzana' and source='es' to find the Spanish entry, then call GET `/entries/{entry_id}` to retrieve the full definition and senses.

### Definition-Driven Content Discovery

Find dictionary entries that mention a target concept inside their definition text - useful for crossword tools, vocabulary builders, and semantic content engines. GET /search-definitions accepts a free-text query and returns entries whose definitions match. This is more powerful than headword search for thematic discovery.

Example prompt: Call GET /search-definitions with text='animal that hibernates' and return the matching entry IDs and headwords.

### Semantic Web and Knowledge Graph Enrichment

Pull dictionary content as RDF/JSON-LD to enrich a knowledge graph or semantic web product. GET /search-rdf and GET `/rdf/{entry_id}` return entries in linked-data format, ready to load into a triple store or graph database. This avoids custom scraping and keeps the lexical data interoperable with other linked-data sources.

Example prompt: Call GET `/rdf/{entry_id}` for the Lexicala entry ID and load the resulting JSON-LD into the project's graph store.

### AI Agent Vocabulary Tool

An AI agent that helps users learn or write in a non-native language can use Lexicala via Jentic to ground responses in authoritative lexical data instead of relying on the LLM's parametric knowledge. Jentic exposes search, entries, senses, and definition-search endpoints as discoverable tools so the agent picks the right one by intent.

Example prompt: Search for 'look up a word in a dictionary', load the GET /search schema, and execute it with the headword and language code provided in agent input.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/languages` | List supported languages and resources |
| GET | `/search` | Search for headwords by spelling |
| GET | `/search-entries` | Search returning complete entries |
| GET | `/entries/{entry_id}` | Retrieve a complete entry by ID |
| GET | `/senses/{sense_id}` | Retrieve a single sense by ID |
| GET | `/search-definitions` | Free-text search over definition text |
| GET | `/rdf/{entry_id}` | Retrieve an entry in RDF/JSON-LD |
| GET | `/fluky-search` | Return a randomly selected entry |

## Key resources

- **Languages** — Available languages and lexical resources on Lexicala
- **Search** — Headword and full-entry search across language resources
- **Entries** — Complete dictionary entries retrieved by ID
- **Senses** — Individual senses within an entry
- **RDF** — RDF/JSON-LD output for linked-data consumers

## Why Jentic

- **Setup:** Wiring the Lexicala Dictionary API by hand means sending its X-RapidAPI-Key header to the RapidAPI host and coding your own calls to the search and entry endpoints. Through Jentic you install once, import the Lexicala Dictionary API from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** Lexicala puts the entry and sense id in the URL path (`/entries/{entry_id}`, `/senses/{sense_id}`), and every operation here is read-only, so a rule can pin your agent to retrieving one entry or sense. You choose the operations it may call, so any beyond those you name are not included.
- **Credential handling:** Your Lexicala RapidAPI key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'look up a word definition' or 'search dictionary entries', and Jentic returns the matching Lexicala operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Wordnik API** — Wordnik is an English-only dictionary API with rich examples; Lexicala is multilingual with linked-data output
- **Merriam-Webster API** — Merriam-Webster is the authoritative English dictionary API; Lexicala covers a wider language set with semantic web output
- **Collins Dictionary API** — Collins offers multilingual dictionary content with strong English coverage; Lexicala leans into RDF/JSON-LD for linked data

## FAQ

### Why is there no official OpenAPI spec for Lexicala Dictionary API?

Lexicala does not publish an OpenAPI specification. Jentic generates and maintains this spec so that AI agents and developers can call Lexicala Dictionary 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 Lexicala Dictionary API use?

Lexicala is distributed via RapidAPI, so calls authenticate using a RapidAPI subscription key passed in the X-RapidAPI-Key header. Through Jentic, the key is stored encrypted in your Jentic One instance and injected at execution time.

### Which languages does Lexicala cover?

Lexicala covers dozens of languages across multiple lexical resources. Call GET /languages to enumerate the available language and resource codes that can be passed as the source parameter on /search and related endpoints.

### What are the rate limits for the Lexicala Dictionary API?

Limits are governed by your RapidAPI plan rather than the API itself; RapidAPI returns 429 with a quota-related header when the plan limit is exceeded. Inspect your plan on the RapidAPI dashboard and cache stable lookups to stay inside the cap.

### How do I search for a word through Jentic?

Run pip install jentic, then search for 'look up a word in a dictionary'. Jentic returns the GET /search operation. Load its schema, pass text (the headword) and source (the language code), then execute the call to get a list of matching entry IDs.

### Can I get linked-data output from this API?

Yes. GET /search-rdf returns search results in RDF/JSON-LD format, and GET `/rdf/{entry_id}` returns a single entry in the same format. These are intended for direct ingestion into a triple store or knowledge graph without further transformation.

### Can I limit what my agent is allowed to do with the Lexicala Dictionary API?

Yes. Because Jentic One is self-hosted, you write the rules that decide which Lexicala operations and credentials your agent may use. Every Lexicala operation is read-only, so you can name just the endpoints you want, for example allowing GET /search and GET `/entries/{entry_id}` while excluding definition search or RDF retrieval. Since the entry and sense identifiers sit in the URL path, a rule can pin the agent to fetching a specific entry or sense, and any operation you do not name is not available to it.