Larousse APIlarousse.fr ↗
Look up French words via the Larousse dictionary API. Get definitions, etymology, synonyms, usage examples, part of speech, and nearby words from 2 endpoints.
What is the Larousse API?
The Larousse French Dictionary API provides access to the full monolingual French dictionary via 2 endpoints, returning structured data including definitions, etymology, part of speech, usage examples, synonyms, and nearby words. The get_definition endpoint retrieves complete word entries — including multiple entries per word where the same form serves different grammatical roles — while search_words supports prefix-based lookup and spelling discovery.
curl -X GET 'https://api.parse.bot/scraper/5d46cd7c-d4d6-4c36-bb5a-4dc34fc6c899/get_definition?word=maison' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace larousse-fr-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: Larousse French Dictionary SDK — look up words, browse definitions."""
from parse_apis.larousse_fr_api import Larousse, WordNotFound
client = Larousse()
# Search for words matching a query
for word in client.words.search(query="maison", limit=5):
print(word.word, word.part_of_speech, word.url)
# Get full definition page for a specific word
page = client.word_pages.get(word="bonjour")
for entry in page.entries:
print(entry.word, entry.part_of_speech)
for defn in entry.definitions:
print(f" - {defn.definition}")
if defn.example:
print(f" Example: {defn.example}")
if defn.synonyms:
print(f" Synonyms: {', '.join(defn.synonyms)}")
# Construct a word and drill into its details
detail = client.word("chat").details()
print(detail.url, detail.nearby_words)
# Handle word not found
try:
client.word_pages.get(word="xyznotaword")
except WordNotFound as exc:
print(f"Not found: {exc.word}")
print("exercised: words.search / word_pages.get / word.details / WordNotFound")
Look up a French word in the Larousse dictionary and return its full entry including all definitions, part of speech, etymology, synonyms, usage examples, and nearby words. A single word may have multiple entries (e.g. noun and adjective forms). Returns input_not_found when the word does not exist in the dictionary.
| Param | Type | Description |
|---|---|---|
| wordrequired | string | French word to look up. Accented characters are supported. |
{
"type": "object",
"fields": {
"url": "string",
"entries": "array of dictionary entries with word, part_of_speech, etymology, definitions",
"expressions": "array of expressions or null",
"nearby_words": "array of nearby words"
},
"sample": {
"data": {
"url": "https://www.larousse.fr/dictionnaires/francais/maison/48725",
"entries": [
{
"word": "maison",
"etymology": "(latinmansio, -onis,demanere,rester)",
"definitions": [
{
"example": "Rue bordée de maisons.",
"synonyms": [
"bâtisse",
"chalet",
"construction",
"villa"
],
"definition": "Bâtiment construit pour servir d'habitation aux personnes ; immeuble"
}
],
"part_of_speech": "nom féminin"
}
],
"expressions": null,
"nearby_words": [
"maisonnage",
"maisonnée"
]
},
"status": "success"
}
}About the Larousse API
What the API Returns
The get_definition endpoint accepts a word parameter (accented characters supported) and returns all dictionary entries for that word. Each entry in the entries array includes the word form, part_of_speech, etymology, and an array of definitions. The response also includes an expressions array (or null when none exist) and a nearby_words array listing alphabetically adjacent entries. A single word can produce multiple entries — for example, a form that functions as both a noun and an adjective will appear as two separate entry objects.
Search and Discovery
The search_words endpoint takes a query string and returns the closest matching Larousse entry along with alphabetically nearby words. Each result in the results array includes the matched word, its part_of_speech, a first_definition preview, and a url back to the full Larousse page. The response also includes a total count of matches. This endpoint is useful for autocomplete, spell-checking, or exploring vocabulary by prefix before committing to a full get_definition call.
Data Shape and Coverage
Both endpoints surface data from the Larousse monolingual French dictionary at larousse.fr/dictionnaires/francais-monolingue. The get_definition response includes the canonical url for the entry, making it straightforward to link back to the source page. Where a word has associated fixed expressions or idiomatic phrases, these appear in the expressions field. The API returns input_not_found when the queried word has no matching entry in the dictionary.
The Larousse API is a managed, monitored endpoint for larousse.fr — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when larousse.fr changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official larousse.fr API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Populate autocomplete suggestions in a French language learning app using
search_wordswith a typed prefix - Build a vocabulary drill tool that surfaces
definitionsandexamplesfromget_definitionfor flashcard generation - Validate French spelling in a form or editor by checking whether a word returns a valid entry or
input_not_found - Extract
etymologyfields to power a historical linguistics research tool - Display contextual
nearby_wordsto help readers explore vocabulary adjacent to an unfamiliar term - Identify
part_of_speechfor each word entry to support French grammar parsing pipelines - Retrieve
expressionsassociated with a word to teach idiomatic usage in a language education platform
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does Larousse offer an official public developer API?+
What does `get_definition` return when a word has multiple grammatical roles?+
entries array will contain one object per grammatical role. For example, a word that functions as both a noun and an adjective will appear as two separate entries, each with its own part_of_speech, definitions, and etymology. The expressions and nearby_words fields are returned once at the top level of the response, not per entry.Does the API cover conjugation tables or verb forms?+
Does `search_words` return multiple pages of results for broad queries?+
total integer indicating how many matches exist, but the endpoint returns the closest matching entry and nearby words without pagination controls. For broad prefix queries, only the most relevant results are returned. You can fork this API on Parse and revise it to add pagination or offset parameters.