Jisho API

Free Japanese dictionary API with no key: search in English, kanji, kana or romaji and get readings, glosses, parts of speech and JLPT tags. Tested example included.

No API key requiredHTTPSFree tier

Endpoint tested and returned HTTP 200 on 2026-08-21

What is the Jisho API?

Jisho.org exposes its word search as a JSON API needing no key. A single `keyword` parameter accepts English, kanji, kana or romaji, and each result returns the written forms with their readings, English definitions grouped by sense, parts of speech and JLPT tags.

Jisho is the dictionary most learners of Japanese actually use, and the search behind it is available as JSON at a stable URL. What makes it more useful than a word list is that it accepts input in any direction: type `house` and you get 家; type 家 and you get its readings; type `ie` in romaji and it resolves that too. One parameter covers all of it.

The response structure repays a careful read. `japanese` is an array because a single entry can have several written forms — kanji, kana-only, older orthography — each paired with its reading. `senses` is an array because words have distinct meanings, and each sense carries its own `parts_of_speech` and `english_definitions`. Flattening the two arrays into a single string, which is the obvious first implementation, is exactly what produces the wrong-sounding definitions you see in hastily built study apps. Note that this endpoint is officially undocumented — it powers the site's own search — so treat it as stable in practice but unguaranteed.

Quick facts

Base URL: https://jisho.org/api/v1
Authentication: No API key and no account. The endpoint is undocumented but public and long-lived.
Rate limit: No published limit. It backs a live website, so keep automated traffic light and cache results.
Pricing: Free.
CORS: Not enabled — call it from your server
Official docs: Read the docs

How to use the Jisho API

Every request below was executed against the live API on 2026-08-21, and the response shown is the real body it returned — not an illustration.

1. Search the dictionary for an English word

GET https://jisho.org/api/v1/search/words?keyword=house

curl

curl 'https://jisho.org/api/v1/search/words?keyword=house'

JavaScript (fetch)

const res = await fetch("https://jisho.org/api/v1/search/words?keyword=house");
if (!res.ok) throw new Error(`Request failed: ${res.status}`);
const data = await res.json();
console.log(data);

Python (requests)

import requests

res = requests.get("https://jisho.org/api/v1/search/words?keyword=house", timeout=20)
res.raise_for_status()
print(res.json())

Response — HTTP 200 (truncated)

{
  "meta": {
    "status": 200
  },
  "data": [
    {
      "slug": "家",
      "is_common": true,
      "tags": [],
      "jlpt": [
        "jlpt-n5"
      ],
      "japanese": [
        {
          "word": "家",
          "reading": "いえ"
        }
      ],
      "senses": [
        {
          "english_definitions": [
            "house",
            "residence",
            "dwelling",
            "home"
          ],
          "parts_of_speech": [
            "Noun"
          ],
          "links": [],
          "tags": [],
          "restrictions": [],
          "see_also": [],
          "antonyms": [],
          "source": [],
          "info": []
        },
        {
          "english_definitions": [
            "family",
            "household"
          ],
          "parts_of_speech": [
            "Noun"
          ],
          "links": [],
          "tags": [],
          "restrictions": [],
          "see_also": [],
          "antonyms": [],
          "source": [],
          "info": []
        },
        {
          "english_definitions": [
            "lineage",
            "family name"
          ],
          "parts_of_speech": [
            "Noun"
          ],
          "links": [],
          "tags": [],
          "restrictions": [],
          "see_also": [],
          "antonyms": [],
          "source": [],
          "info": []
        }
      ],
      "attribution": {
        "jmdict": true,
        "jmnedict": false,
        "dbpedia": false
      }
    },
    {
      "slug": "家屋",
      "is_common": true,
      "tags": [],
      "jlpt": [
        "jlpt-n2"

Parameters

Parameter	Type	Required	Description
`keyword`	query	Required	Search term. Accepts English, kanji, kana or romaji, and supports Jisho's own operators such as `#jlpt-n5` or `*` wildcards. `house`
`page`	query	Optional	1-based page of results. Twenty entries per page. `1`

Response fields

meta.statusinteger: Status echoed inside the body — 200 on success. Check it as well as the HTTP status.
dataarray: Matching dictionary entries, best match first.
data[].slugstring: Canonical identifier for the entry, usually the primary written form.
data[].is_commonboolean: Whether Jisho marks the word as common. The single most useful filter for learners.
data[].jlptarray: JLPT level tags such as `jlpt-n5`. Empty for words outside the exam lists.
data[].japanesearray: Written forms paired with readings — `word` holds the kanji form, `reading` the kana. Either can be absent for kana-only or reading-only entries.
data[].sensesarray: Distinct meanings. Each carries `english_definitions`, `parts_of_speech`, plus `tags`, `see_also`, `antonyms` and usage `info`.
data[].attributionobject: Which source dictionaries the entry came from, such as JMdict or DBpedia.

What you can build with the Jisho API

Add a lookup panel to a Japanese reading or subtitle tool
Build flashcards filtered to common words at a given JLPT level
Resolve romaji input to the correct kanji spelling
Check the part of speech of a word before generating a conjugation drill

Common errors and how to fix them

Definitions look wrong or mixed up

The `senses` array was flattened into one string.

Fix: Render each sense separately with its own parts of speech. A word with five senses is five distinct meanings, not one long list.

`word` is missing on an entry

Kana-only words have a `reading` but no kanji form.

Fix: Fall back to `reading` when `word` is absent rather than rendering undefined.

Cross-origin request blocked

No Access-Control-Allow-Origin header is sent.

Fix: Call it from a server. The endpoint is undocumented, so browser access is not something to rely on.

Rate limited or blocked

The endpoint backs a live public website.

Fix: Cache per keyword and keep concurrency low. It is not intended for bulk corpus processing.

Jisho API — frequently asked questions

Is the Jisho API official?

It is public and has powered Jisho's own search for years, but it is undocumented and carries no compatibility guarantee. Treat it as stable in practice rather than contractually stable.

Can I search in English?

Yes. The same `keyword` parameter takes English, kanji, kana or romaji and works out which you meant, so one endpoint covers both lookup directions.

Why does one entry have several japanese objects?

A word can have multiple written forms — a kanji spelling, a kana-only spelling, an older orthography — and each is paired with its own reading. Show the first as primary and the rest as variants.

How do I filter to beginner vocabulary?

Combine `is_common` with the `jlpt` tags. Jisho also accepts its own search operators inside the keyword itself, so `#jlpt-n5 house` works.

Tools that pair with this API

Unicode Character Inspector

Inspect any text character by character: Unicode code points, UTF-8 bytes, UTF-16 units, HTML entities, CSS and JS escapes, plus NFC, NFD, NFKC and NFKD forms.

Character Counter

Count characters with and without spaces in real time and check limits for Twitter/X, Instagram captions, meta descriptions and SMS messages.

Word Counter

Count words, characters, sentences, paragraphs and estimated reading time instantly. Free online word counter for essays, blogs and social media.

Jisho is an independent third-party service and is not affiliated with ByteTools or ByteVancer. Details on this page were verified on 2026-08-21; always check the official documentation before relying on this API in production, as terms and limits can change.