KanjiAPI

Free kanji API with no key: readings, meanings, stroke count, JLPT level, school grade and Heisig keyword for any character. Tested example included.

No API key requiredCORS enabledHTTPSFree tier

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

What is the KanjiAPI?

KanjiAPI is a free, key-free JSON API for Japanese kanji. Requesting a character returns its on and kun readings, English meanings, stroke count, JLPT level, the school grade it is taught in and its Heisig keyword.

Learning kanji means constantly needing the same handful of facts about a character — how it is read, what it means, how many strokes, when it is taught — and those facts have historically lived in KANJIDIC, a fixed-width text file everyone has to parse for themselves. KanjiAPI does that parsing once and serves the result as JSON over HTTPS with CORS enabled, which is why a great many browser-based study tools sit on top of it.

The pedagogically useful fields are `grade` and `jlpt`. `grade` is the Japanese school year in which the character is taught, so grades 1 to 6 give you the Kyoiku kanji in the order Japanese children actually learn them; `jlpt` is the proficiency-exam level, which is how foreign learners usually sequence their study. Between them you can build a study order matching whichever curriculum your users follow. Note that the character in the path must be percent-encoded, and that `kun_readings` sometimes contains okurigana markers such as a leading hyphen.

Quick facts

Base URL: https://kanjiapi.dev/v1
Authentication: No API key and no account. The project is open source and the data derives from KANJIDIC.
Rate limit: No published limit. Responses are static per character and heavily cacheable.
Pricing: Free.
CORS: Enabled — callable directly from browser JavaScript
Official docs: Read the docs

How to use the KanjiAPI

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. Look up a single kanji character

GET https://kanjiapi.dev/v1/kanji/%E5%AD%97

curl

curl 'https://kanjiapi.dev/v1/kanji/%E5%AD%97'

JavaScript (fetch)

const res = await fetch("https://kanjiapi.dev/v1/kanji/%E5%AD%97");
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://kanjiapi.dev/v1/kanji/%E5%AD%97", timeout=20)
res.raise_for_status()
print(res.json())

Response — HTTP 200

{
  "alternate_stroke_counts": [],
  "freq_mainichi_shinbun": 485,
  "grade": 1,
  "heisig_en": "character",
  "jlpt": 4,
  "kanji": "字",
  "kun_readings": [
    "あざ",
    "あざな",
    "-な"
  ],
  "meanings": [
    "character",
    "letter",
    "word",
    "section of village"
  ],
  "name_readings": [],
  "notes": [],
  "on_readings": [
    "ジ"
  ],
  "stroke_count": 6,
  "unicode": "5B57"
}

Parameters

Parameter	Type	Required	Description
`(character)`	path	Required	The kanji itself, percent-encoded in the URL. `%E5%AD%97`
`/kanji/all`	path	Optional	Alternative path returning every kanji in the dataset as an array of characters.
`/reading/{reading}`	path	Optional	Reverse lookup: every kanji that uses a given reading.
`/words/{kanji}`	path	Optional	Vocabulary words containing the character, with readings and glosses.

Response fields

kanjistring: The character itself, echoed back.
meaningsarray: English glosses, most common first.
on_readingsarray: On'yomi readings in katakana — the Sino-Japanese readings.
kun_readingsarray: Kun'yomi readings in hiragana. A leading or trailing hyphen marks okurigana or a prefix position.
name_readingsarray: Readings used only in personal and place names. Often empty.
stroke_countinteger: Standard stroke count, with any variants listed in `alternate_stroke_counts`.
gradeinteger: Japanese school grade the character is taught in. 1-6 are the Kyoiku kanji; 8 marks general-use kanji taught later; null means it sits outside the standard lists.
jlptinteger: Japanese Language Proficiency Test level, where 4 is easier and 1 is hardest. Null for characters outside the exam lists.
heisig_enstring: The keyword from Heisig's Remembering the Kanji, for users studying by that method.
freq_mainichi_shinbuninteger: Frequency rank in a newspaper corpus — lower means more common.
unicodestring: Hexadecimal Unicode code point.

What you can build with the KanjiAPI

Build a kanji flashcard app sequenced by school grade or JLPT level
Add a hover dictionary to a Japanese reading tool
Generate stroke-count-ordered practice worksheets
Cross-reference Heisig keywords against JLPT levels for a study plan

Common errors and how to fix them

404

The character is not in the dataset, or the URL was not percent-encoded.

Fix: Encode the character before putting it in the path. Also check you sent a kanji rather than kana — hiragana and katakana are not covered.

null grade or jlpt

The character sits outside the standard school and exam lists.

Fix: That is genuine data, not an error. Handle nulls rather than assuming every kanji has a level.

Hyphens inside kun_readings

Those are okurigana position markers inherited from KANJIDIC.

Fix: Strip them for display, but keep them if you are generating conjugations — they mark where the inflected ending attaches.

KanjiAPI — frequently asked questions

Is KanjiAPI free?

Yes, free with no key and no account. It is an open source project serving data derived from the KANJIDIC dictionary file.

What is the difference between grade and jlpt?

`grade` is the Japanese school year in which the character is taught, so it follows the curriculum native children go through. `jlpt` is the proficiency-exam level foreign learners usually study by. They sequence characters quite differently.

Why do some readings have a hyphen?

Those are okurigana markers from KANJIDIC. They show where an inflected ending attaches, or that the reading only appears as a prefix. Strip them for plain display.

Can I look up words rather than single characters?

Yes. The `/words/{kanji}` path returns vocabulary containing the character, and `/reading/{reading}` does the reverse lookup from a reading back to characters.

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.

Syllable Counter

Count syllables in any word, sentence or paragraph instantly, with a per-word breakdown. Great for poetry, haiku and readability. 100% in-browser.

KanjiAPI 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.