Introduction

The Yomit.ai API gives you everything the website does from your own scripts and apps: the dictionary, kanji and grammar references, the reading, image, listening, and writing tools, My Notes, and your account. Every feature your plan includes on the website is available here with the same limits.

The API is organised around REST. It uses HTTP verbs and response codes, accepts ordinary form encoded request bodies, and returns JSON from every endpoint, including errors. The two endpoints that produce files return the file itself.

All endpoints live under https://api.yomit.ai/v1. The v1 in the path is the API version; changes that would break existing clients will get a new version and v1 will keep working.

Pick a language on the right to see every request example in it.

Language:

BASE URL
https://api.yomit.ai/v1

Authentication

Every request is authenticated with your API token, sent in the Authorization header as a bearer token. The token identifies your account, so the API sees the same plan, notes, and AI allowance as the website. Requests without a valid token fail with 401.

You have one token at a time. Regenerating it invalidates the previous one immediately, deleting it turns API access off until you create a new one. Keep it secret: do not put it in client-side code or public repositories, and regenerate it if it leaks.

All requests must be made over HTTPS.

Authorization: Bearer abcdef1234567890

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Account

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Account',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Account", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Account'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Account")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

Requests & Responses

Parameters use the same forms_ names as the website. GET endpoints take them in the query string. POST endpoints take them as form fields in the request body (application/x-www-form-urlencoded); /ImageAssistant needs multipart/form-data because it uploads a file. JSON request bodies are not accepted. Text is UTF-8 everywhere.

Every JSON response is an object with a message and, on success, a result. The message is empty on success unless there is something worth saying (for example that a search found nothing); on failure it explains what went wrong in plain language you can show to a user.

Endpoints that change things (/Notes, /Account) only ever touch the data of the account behind the token, and ids that belong to another account are reported as not found.

Requests are limited to 200 per two minutes from one address; beyond that the API answers 429 until the window passes.

A POST with form fields, and the error when a required field is missing

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_text=毎朝パンを食べる。" \
https://api.yomit.ai/v1/ReadingAssistant

<?php

$curl = curl_init();
$data = array(
'forms_text' => '毎朝パンを食べる。',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/ReadingAssistant',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_text", "毎朝パンを食べる。")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/ReadingAssistant", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/ReadingAssistant'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_text': '毎朝パンを食べる。',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/ReadingAssistant")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_text" => "毎朝パンを食べる。" })

response = https.request(request)
puts response.read_body

{"message":"The \"Text\" field is required"}

Plans

The API follows your plan exactly as the website does. Every study tool is included in every plan, with the Reading Assistant and Listening Practice character limits and the writing practice sheet allowance growing with the plan. The AI features need the Kanji plan or higher and draw on the same monthly token allowance as the website; My Notes needs the Bunko plan or higher; exporting books needs the Sensei plan. An endpoint your plan does not include answers 403 with a message that says which plan does.

Where AI is optional (/ImageAssistant, /ListeningPractice) it is off unless you send forms_ai_enabled=1, and the standard engine is used when your allowance is spent. GET /Account tells you how much of the allowance is left.

Kana (0.00 USD per month)
Dictionary, JLPT grammar, hiragana & katakana
Reading Assistant: 10 texts a month, 100 characters at a time
Listening practice: 10 texts a month, 50 characters at a time
Image Assistant text recognition: 10 images a month
Writing practice: 10 pages a month, up to 1 characters per sheet

Kanji (2.99 USD per month)
Dictionary, JLPT grammar, hiragana & katakana
Reading Assistant: 25 texts a month, 150 characters at a time
Listening practice: 25 texts a month, 150 characters at a time
Image Assistant text recognition: 25 images a month
Writing practice: 25 pages a month, up to 3 characters per sheet
Writing practice sheet options
AI word & sentence explanations
AI vision for photos & natural AI voice
150,000 AI tokens every month

Bunko (7.99 USD per month)
Dictionary, JLPT grammar, hiragana & katakana
Reading Assistant: 75 texts a month, 500 characters at a time
Listening practice: 75 texts a month, 500 characters at a time
Image Assistant text recognition: 75 images a month
Writing practice: 75 pages a month, up to 10 characters per sheet
Writing practice sheet options
AI word & sentence explanations
AI vision for photos & natural AI voice
500,000 AI tokens every month
My Notes: books, pages & notes on any word
AI note tools: improve, summarize, quiz

Sensei (12.99 USD per month)
Dictionary, JLPT grammar, hiragana & katakana
Reading Assistant: 200 texts a month, 1,500 characters at a time
Listening practice: 200 texts a month, 1,500 characters at a time
Image Assistant text recognition: 200 images a month
Writing practice: 200 pages a month, up to 25 characters per sheet
Writing practice sheet options
AI word & sentence explanations
AI vision for photos & natural AI voice
1,200,000 AI tokens every month
My Notes: books, pages & notes on any word
AI note tools: improve, summarize, quiz
Export notes to PDF, Word & Excel

A feature outside your plan

{"message":"My Notes is included in the Bunko and Sensei plans, please upgrade your plan to keep notes"}

Errors

The API uses conventional HTTP response codes. Codes in the 2xx range mean the request worked. Codes in the 4xx range mean the request could not be carried out with the information given (a missing parameter, a token that is not valid, a feature outside your plan, an id that is not yours). Codes in the 5xx range mean something went wrong on our side or in a service we depend on; these are rare and safe to retry after a moment.

Every error is a JSON object whose message explains the problem, including which field failed validation.

200 - OK - Everything worked as expected.

400 - Bad Request - A required parameter is missing or a value is not acceptable; the message says which.

401 - Unauthorized - No valid API token was sent.

403 - Forbidden - Your plan does not include this feature, or your AI allowance for this billing period is used up.

404 - Not Found - The endpoint does not exist, or the id is not one of yours.

429 - Too Many Requests - More than 200 requests in two minutes; wait and try again.

500 - Server Error - Something went wrong on our side.

502 - Bad Gateway - The AI, speech, or text recognition service did not answer; try again later.

503 - Service Unavailable - The feature is not enabled on this server.

{"message":"The \"Kanji\" field is required"}

Search the dictionary

Look up Japanese, romaji, or English exactly as the dictionary page does. Conjugated words are reduced to their dictionary form, a phrase is split into its words and each word is looked up, and any kanji in the query come back with their details. A * stands in for the rest of a word: 駅* starts with 駅, *屋 ends with 屋, *雨* contains 雨, and 電*車 starts with 電 and ends with 車.

Results are paged 20 words at a time; use forms_start with a value from page_array to fetch another page.

Arguments

forms_query

required

string

The text to look up, up to 200 characters: a word in kanji or kana (食べる, たべる), romaji (taberu), English (to eat), a short phrase, or a wildcard (駅*, *屋, *雨*).

forms_start

optional

integer

Zero based offset of the first word to return, defaults to 0.

Returns

An object with query, how the query was read (type: japanese, romaji, english, or pattern), the matching words with their readings and senses, the kanji found in the query, the tokens of a phrase, pattern (null, or the wildcard with kind, text, prefix, and suffix), readings (hiragana for a query of one to four kanji, each with literal, kun, and on), offer (null, or a dictionary-collection suggestion with id, value, action, and question), and the paging fields total_rows, current_page, total_pages, and page_array.

GET https://api.yomit.ai/v1/Dictionary

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_query=食べる" \
https://api.yomit.ai/v1/Dictionary

<?php

$curl = curl_init();
$data = array(
'forms_query' => '食べる',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Dictionary?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_query", "食べる")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Dictionary?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Dictionary'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_query': '食べる',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Dictionary")
url.query = URI.encode_www_form({ "forms_query" => "食べる" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"query":"食べる","type":"japanese","words":[{"id_japanese_word":"00000000-0000-4000-a000-000000000050","sequence":1358280,"source":"JMdict","common":true,"kanji_elements":[{"written_form":"食べる","common":true},{"written_form":"喰べる","common":false}],"reading_elements":[{"reading":"たべる","restriction":[],"common":true}],"senses":[{"part_of_speech":["Ichidan verb","transitive verb"],"cross_reference":[],"sense_information":"","miscellaneous":[],"glosses":["to eat"]},{"part_of_speech":["Ichidan verb","transitive verb"],"cross_reference":[],"sense_information":"","miscellaneous":[],"glosses":["to live on (e.g. a salary)","to live off","to subsist on"]}],"named_entities":[],"primary_written_form":"食べる","primary_reading":"たべる"}],"total_rows":1,"kanji":[{"id_japanese_kanji":"00000000-0000-4000-a000-000000000060","literal":"食","codepoint":"098df","grade":2,"stroke_count":9,"frequency":328,"jlpt":4,"readings":{"on":["ショク","ジキ"],"kun":["く.う","く.らう","た.べる","は.む"],"other":[{"type":"pinyin","reading":"shi2"}]},"meanings":["eat","food"],"nanori":["ぐい"],"radical":{"number":184,"character":"食","strokes":9},"components":["人","良","食"]}],"tokens":[],"pattern":null,"readings":[],"offer":null,"current_page":1,"total_pages":1,"page_array":[1]}}

Explain a word with AI

The "Explain with AI" button of the dictionary: a teacher style explanation of a word, on its own or as it is used in a passage, with readings, meaning, grammar notes, and example sentences.

Plan: the Kanji plan or higher. Each call spends AI tokens from your monthly allowance; when the allowance is used up the call fails with 403.

Arguments

forms_word

required

string

The word to explain, up to 100 characters.

forms_context

optional

string

The sentence or passage the word appears in, up to 1,000 characters. When given, the explanation is about the word as used in this passage.

Returns

An object with the word, the explanation as markdown, and the same explanation rendered as html.

POST https://api.yomit.ai/v1/Dictionary/Explain

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_word=食べる" \
--data-urlencode "forms_context=毎朝パンを食べる。" \
https://api.yomit.ai/v1/Dictionary/Explain

<?php

$curl = curl_init();
$data = array(
'forms_word' => '食べる',
'forms_context' => '毎朝パンを食べる。',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Dictionary/Explain',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_word", "食べる")
data.Set("forms_context", "毎朝パンを食べる。")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Dictionary/Explain", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Dictionary/Explain'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_word': '食べる',
'forms_context': '毎朝パンを食べる。',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Dictionary/Explain")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_word" => "食べる", "forms_context" => "毎朝パンを食べる。" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"word":"食べる","markdown":"### 食べる (たべる)\n\n- **Meaning here:** to eat\n- **Part of speech:** ichidan verb, dictionary form\n\n**Example:** 妹はりんごを食べる。 — My sister eats an apple.","html":"<h3>食べる (たべる)</h3><ul><li><strong>Meaning here:</strong> to eat</li><li><strong>Part of speech:</strong> ichidan verb, dictionary form</li></ul><p><strong>Example:</strong> 妹はりんごを食べる。 — My sister eats an apple.</p>"}}

Get a dictionary collection

A dictionary collection: Body, Clock, Colours, Connectors, Counters, Demonstratives, Family, Feelings, Frequency, House, Numbers, Position, Questions, Time, or Weather. Words are ordinary dictionary entries. Counters add the reading from one to ten, colours add a swatch and a pale wash, and numbers can also convert a whole number. The other lists add the everyday reading and the other forms under each card. Body, clock, demonstratives, family, feelings, frequency, house, position, time, and weather also include a scene, boxes of labels above the cards. A scene has kind, introduction, flow, and rows. A row has name, marks, and groups. A group has name and marks. A mark has kanji, reading, label, slot, emoji, and query.

Arguments

forms_collection

required

string

One of body, clock, colours, connectors, counters, demonstratives, family, feelings, frequency, house, numbers, position, questions, time, weather.

forms_collection_value

optional

string

A whole number from 0 to 9999兆, used when forms_collection is numbers. Commas are ignored.

Returns

An object with id, title, introduction, number (the conversion, or null), scene (null, or the boxes above the cards), and groups. Each group has name, introduction, entries (a word plus label, note, readings, swatch, and wash), and grid for the days and months. A converted number has kanji, reading, also, and counters.

GET https://api.yomit.ai/v1/Dictionary/Collection

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_collection=numbers" \
--data-urlencode "forms_collection_value=3847" \
https://api.yomit.ai/v1/Dictionary/Collection

<?php

$curl = curl_init();
$data = array(
'forms_collection' => 'numbers',
'forms_collection_value' => '3847',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Dictionary/Collection?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_collection", "numbers")
data.Set("forms_collection_value", "3847")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Dictionary/Collection?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Dictionary/Collection'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_collection': 'numbers',
'forms_collection_value': '3847',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Dictionary/Collection")
url.query = URI.encode_www_form({ "forms_collection" => "numbers", "forms_collection_value" => "3847" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"id":"numbers","title":"Numbers","introduction":"Type a number to see how it is read, and how the counters change with it.","number":{"input":"3847","value":3847,"kanji":"三千八百四十七","reading":"さんぜんはっぴゃくよんじゅうなな","also":"","error":"","counters":[{"kanji":"三千八百四十七本","reading":"さんぜんはっぴゃくよんじゅうななほん","label":"long, thin things","query":"本"}]},"scene":null,"groups":[{"name":"Digits and large numbers","introduction":"","entries":[{"word":{"id_japanese_word":"00000000-0000-4000-a000-000000000050","sequence":1358280,"source":"JMdict","common":true,"kanji_elements":[{"written_form":"食べる","common":true},{"written_form":"喰べる","common":false}],"reading_elements":[{"reading":"たべる","restriction":[],"common":true}],"senses":[{"part_of_speech":["Ichidan verb","transitive verb"],"cross_reference":[],"sense_information":"","miscellaneous":[],"glosses":["to eat"]},{"part_of_speech":["Ichidan verb","transitive verb"],"cross_reference":[],"sense_information":"","miscellaneous":[],"glosses":["to live on (e.g. a salary)","to live off","to subsist on"]}],"named_entities":[],"primary_written_form":"食べる","primary_reading":"たべる"},"label":"one","note":"","readings":[],"swatch":"","wash":""}],"grid":[]}]}}

Convert kana to kanji

The words a kana reading could be written as, most likely first, the candidates the dictionary page offers when a search is typed in kana. A longer phrase in kana is converted as a whole.

Arguments

forms_reading

required

string

Hiragana or katakana only, up to 60 characters.

Returns

An object with the reading and an array of candidates (strings).

GET https://api.yomit.ai/v1/KanaConversion

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_reading=きょうはいいてんき" \
https://api.yomit.ai/v1/KanaConversion

<?php

$curl = curl_init();
$data = array(
'forms_reading' => 'きょうはいいてんき',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/KanaConversion?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_reading", "きょうはいいてんき")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/KanaConversion?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/KanaConversion'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_reading': 'きょうはいいてんき',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/KanaConversion")
url.query = URI.encode_www_form({ "forms_reading" => "きょうはいいてんき" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"reading":"きょうはいいてんき","candidates":["今日はいい天気","今日は良い天気","キョウハイイテンキ"]}}

Conjugate a verb or adjective

Every conjugation of a verb or adjective, as the conjugation table on the dictionary page shows them. When the part of speech is not given it is worked out from the word itself, first with the text analyser, then from the dictionary.

Arguments

forms_word

required

string

The dictionary form, usually with kanji (食べる, 高い, 静か).

forms_reading

optional

string

The kana reading of the dictionary form, used to build the readings of the conjugated forms. Worked out when omitted.

forms_part_of_speech

optional

string

The part of speech from a dictionary sense (e.g. Ichidan verb, Godan verb with 'ru' ending, adjective (keiyoushi)). Worked out when omitted.

Returns

An object with the word, reading, word class (type and type_label), and inflections: an array of forms, each with form, affirmative, negative, affirmative_reading, and negative_reading.

GET https://api.yomit.ai/v1/Inflection

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_word=食べる" \
--data-urlencode "forms_reading=たべる" \
https://api.yomit.ai/v1/Inflection

<?php

$curl = curl_init();
$data = array(
'forms_word' => '食べる',
'forms_reading' => 'たべる',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Inflection?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_word", "食べる")
data.Set("forms_reading", "たべる")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Inflection?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Inflection'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_word': '食べる',
'forms_reading': 'たべる',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Inflection")
url.query = URI.encode_www_form({ "forms_word" => "食べる", "forms_reading" => "たべる" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"word":"食べる","reading":"たべる","type":"ichidan","type_label":"Ichidan (る) verb","inflections":[{"form":"Plain","affirmative":"食べる","negative":"食べない","affirmative_reading":"たべる","negative_reading":"たべない"},{"form":"Polite","affirmative":"食べます","negative":"食べません","affirmative_reading":"たべます","negative_reading":"たべません"},{"form":"Past","affirmative":"食べた","negative":"食べなかった","affirmative_reading":"たべた","negative_reading":"たべなかった"}]}}

Get a kanji

Everything the dictionary shows for one kanji: on and kun readings, meanings, name readings, school grade, JLPT level, stroke count, frequency rank, classical radical and components, whether a stroke order diagram is available, and common words written with it.

Arguments

forms_kanji

required

string

A single kanji character.

Returns

A kanji object with stroke_order_available and words (an array of word entries) added.

GET https://api.yomit.ai/v1/Kanji

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_kanji=食" \
https://api.yomit.ai/v1/Kanji

<?php

$curl = curl_init();
$data = array(
'forms_kanji' => '食',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Kanji?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_kanji", "食")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Kanji?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Kanji'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_kanji': '食',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Kanji")
url.query = URI.encode_www_form({ "forms_kanji" => "食" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_japanese_kanji":"00000000-0000-4000-a000-000000000060","literal":"食","codepoint":"098df","grade":2,"stroke_count":9,"frequency":328,"jlpt":4,"readings":{"on":["ショク","ジキ"],"kun":["く.う","く.らう","た.べる","は.む"],"other":[{"type":"pinyin","reading":"shi2"}]},"meanings":["eat","food"],"nanori":["ぐい"],"radical":{"number":184,"character":"食","strokes":9},"components":["人","良","食"],"stroke_order_available":true,"words":[{"id_japanese_word":"00000000-0000-4000-a000-000000000050","sequence":1358280,"source":"JMdict","common":true,"kanji_elements":[{"written_form":"食べる","common":true},{"written_form":"喰べる","common":false}],"reading_elements":[{"reading":"たべる","restriction":[],"common":true}],"senses":[{"part_of_speech":["Ichidan verb","transitive verb"],"cross_reference":[],"sense_information":"","miscellaneous":[],"glosses":["to eat"]},{"part_of_speech":["Ichidan verb","transitive verb"],"cross_reference":[],"sense_information":"","miscellaneous":[],"glosses":["to live on (e.g. a salary)","to live off","to subsist on"]}],"named_entities":[],"primary_written_form":"食べる","primary_reading":"たべる"}]}}

List the radicals

The 214 classical radicals grouped by stroke count, the radical picker of the dictionary page. Use the radical number values with /Kanji/Radicals.

Returns

An object keyed by stroke count; each value is an array of radicals with their number and character.

GET https://api.yomit.ai/v1/Radicals

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Radicals

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Radicals',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Radicals", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Radicals'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Radicals")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"1":[{"number":1,"character":"一"},{"number":2,"character":"丨"},{"number":3,"character":"丶"}],"2":[{"number":7,"character":"二"},{"number":9,"character":"人"}]}}

Find kanji by radicals

The kanji that contain every radical in a list, most frequent first, as the radical picker finds them.

Arguments

forms_radical_list

required

integer list

Up to 10 radical numbers (1 to 214) separated by commas, from /Radicals.

Returns

An array of kanji objects, at most 60. The message explains an empty result.

GET https://api.yomit.ai/v1/Kanji/Radicals

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_radical_list=9,184" \
https://api.yomit.ai/v1/Kanji/Radicals

<?php

$curl = curl_init();
$data = array(
'forms_radical_list' => '9,184',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Kanji/Radicals?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_radical_list", "9,184")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Kanji/Radicals?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Kanji/Radicals'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_radical_list': '9,184',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Kanji/Radicals")
url.query = URI.encode_www_form({ "forms_radical_list" => "9,184" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":[{"id_japanese_kanji":"00000000-0000-4000-a000-000000000060","literal":"食","codepoint":"098df","grade":2,"stroke_count":9,"frequency":328,"jlpt":4,"readings":{"on":["ショク","ジキ"],"kun":["く.う","く.らう","た.べる","は.む"],"other":[{"type":"pinyin","reading":"shi2"}]},"meanings":["eat","food"],"nanori":["ぐい"],"radical":{"number":184,"character":"食","strokes":9},"components":["人","良","食"]}]}

Browse the JLPT grammar

The grammar reference in two shapes. With no arguments, how many grammar points there are per level. With forms_grammar_level, one page of the points of that level (optionally filtered by forms_term). Fetch the usage rules and example sentences of one point with /Grammar/{GRAMMAR_ID}.

Arguments

forms_grammar_level

optional

string

One of n5, n4, n3, n2, n1.

forms_term

optional

string

Only return points whose pattern or meaning contains this text (up to 100 characters). Also filters the counts.

forms_start

optional

integer

Zero based offset of the first point of a level to return, defaults to 0.

Returns

The counts shape is {"counts": {"n5": 123, ...}}. The level shape adds item_list (summaries with id_japanese_grammar, level, pattern, meaning, and one example) and the paging fields.

GET https://api.yomit.ai/v1/Grammar

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_grammar_level=n5" \
--data-urlencode "forms_term=たい" \
https://api.yomit.ai/v1/Grammar

<?php

$curl = curl_init();
$data = array(
'forms_grammar_level' => 'n5',
'forms_term' => 'たい',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Grammar?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_grammar_level", "n5")
data.Set("forms_term", "たい")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Grammar?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Grammar'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_grammar_level': 'n5',
'forms_term': 'たい',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Grammar")
url.query = URI.encode_www_form({ "forms_grammar_level" => "n5", "forms_term" => "たい" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"item_list":[{"id_japanese_grammar":"00000000-0000-4000-a000-000000000040","level":"n5","pattern":"〜たい","meaning":"want to do","example":"寿司を食べたい。"}],"total_rows":1,"current_page":1,"total_pages":1,"page_array":[1],"counts":{"n5":1,"n4":0,"n3":0,"n2":0,"n1":0},"level":"n5","term":"たい"}}

Get a grammar point

One grammar point in full: its usage rules by word class and every example sentence, grouped by the JLPT level of the hardest vocabulary word each sentence contains.

Arguments

{GRAMMAR_ID}

required

uuid

The id of the grammar point, from a /Grammar level listing, as the last part of the path.

Returns

The point with id_japanese_grammar, level, pattern, meaning, usage (each rule with word_class, rule, rule_annotated, and example), and examples (each with level, japanese, and english). In rule_annotated every term from the key of the grammar page, such as [Verb て-form], is wrapped in square brackets so it can be picked out and explained.

GET https://api.yomit.ai/v1/Grammar/{GRAMMAR_ID}

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Grammar/00000000-0000-4000-a000-000000000040

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Grammar/00000000-0000-4000-a000-000000000040',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Grammar/00000000-0000-4000-a000-000000000040", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Grammar/00000000-0000-4000-a000-000000000040'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Grammar/00000000-0000-4000-a000-000000000040")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_japanese_grammar":"00000000-0000-4000-a000-000000000040","level":"n5","pattern":"〜たい","meaning":"want to do","usage":[{"word_class":"verb","rule":"Verb stem + たい","rule_annotated":"[Verb stem] + たい","example":"食べたい、行きたい"}],"examples":[{"level":"n5","japanese":"寿司を食べたい。","english":"I want to eat sushi."},{"level":"n4","japanese":"将来、日本で働きたい。","english":"I want to work in Japan in the future."}]}}

Get the hiragana chart

The hiragana chart, table by table, exactly as the hiragana page draws it: the basic sounds, the voiced and semi-voiced sounds, and the combinations.

Returns

An array of tables, each with a title, a description, and columns keyed by the column's romaji; each column is an array of five cells (empty where the chart has a gap) with kana, romaji, and typing (what to type for it).

GET https://api.yomit.ai/v1/Hiragana

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Hiragana

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Hiragana',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Hiragana", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Hiragana'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Hiragana")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":[{"title":"Basic Hiragana","description":"The 46 basic sounds. Hiragana is used for native Japanese words, grammatical particles, and verb endings.","columns":{"a":[{"kana":"あ","romaji":"a","typing":"a"},{"kana":"い","romaji":"i","typing":"i"},{"kana":"う","romaji":"u","typing":"u"},{"kana":"え","romaji":"e","typing":"e"},{"kana":"お","romaji":"o","typing":"o"}]}}]}

Get the katakana chart

The katakana chart in the same shape as /Hiragana, including the extra combinations used for loanwords.

Returns

An array of tables, see /Hiragana.

GET https://api.yomit.ai/v1/Katakana

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Katakana

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Katakana',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Katakana", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Katakana'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Katakana")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":[{"title":"Basic Katakana","description":"The same 46 sounds as hiragana. Katakana is used for loanwords, foreign names, onomatopoeia, and emphasis.","columns":{"a":[{"kana":"ア","romaji":"a","typing":"a"},{"kana":"イ","romaji":"i","typing":"i"},{"kana":"ウ","romaji":"u","typing":"u"},{"kana":"エ","romaji":"e","typing":"e"},{"kana":"オ","romaji":"o","typing":"o"}]}}]}

Analyse a passage

Split a passage of Japanese into words with their readings and parts of speech, the analysis behind the reading assistant. Look up any word with /Dictionary and conjugate verbs with /Inflection.

Plan: every plan has a monthly allowance of texts to analyse (10, 25, 75, or 200 from the free plan up); each successful call counts as one, and the call answers 403 once the allowance is spent. The text read from an image by /ImageAssistant already comes back split into words, so it does not need this call.

Arguments

forms_text

required

string

The Japanese text. The limit depends on your plan: 100, 150, 500, or 1,500 characters from the free plan up; longer text answers 403. Line breaks are kept.

Returns

An array of tokens in reading order, each with surface (as written), lemma (dictionary form), reading (hiragana), part_of_speech (Japanese), part_of_speech_english, is_symbol, and is_verb.

POST https://api.yomit.ai/v1/ReadingAssistant

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_text=毎朝パンを食べる。" \
https://api.yomit.ai/v1/ReadingAssistant

{"message":"","result":[{"surface":"毎朝","lemma":"毎朝","reading":"まいあさ","part_of_speech":"名詞","part_of_speech_english":"noun","is_symbol":false,"is_verb":false},{"surface":"パン","lemma":"パン","reading":"ぱん","part_of_speech":"名詞","part_of_speech_english":"noun","is_symbol":false,"is_verb":false},{"surface":"を","lemma":"を","reading":"を","part_of_speech":"助詞","part_of_speech_english":"particle","is_symbol":false,"is_verb":false},{"surface":"食べる","lemma":"食べる","reading":"たべる","part_of_speech":"動詞","part_of_speech_english":"verb","is_symbol":false,"is_verb":true},{"surface":"。","lemma":"。","reading":"。","part_of_speech":"補助記号","part_of_speech_english":"symbol","is_symbol":true,"is_verb":false}]}

Read the text in an image

Read the Japanese text out of a photo or screenshot, the image assistant. Send the image as a multipart/form-data upload. Standard text recognition is included in every plan; AI vision reads handwriting and busy photos far better.

Plan: every plan has a monthly allowance of images to read (10, 25, 75, or 200 from the free plan up); each successful call counts as one, and the call answers 403 once the allowance is spent. AI vision needs the Kanji plan or higher and spends AI tokens. When your token allowance is used up the standard recognition is used instead and notice says so.

Arguments

forms_image_file

required

file

A JPEG, PNG, WebP, or GIF image up to 5 MB.

forms_ai_enabled

optional

integer

1 to read the image with AI vision, 0 (the default) for the standard recognition.

Returns

An object with the recognised text (line breaks preserved), the same text split into tokens in the shape /ReadingAssistant returns (an empty array when word splitting was unavailable), the engine that produced it (ai or ocr), and a notice when AI was requested but not used.

POST https://api.yomit.ai/v1/ImageAssistant

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
-F "forms_image_file=@photo.jpg" \
-F "forms_ai_enabled=1" \
https://api.yomit.ai/v1/ImageAssistant

<?php

$curl = curl_init();
$data = array(
'forms_image_file' => new CURLFile('photo.jpg'),
'forms_ai_enabled' => '1',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/ImageAssistant',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => $data,
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"bytes"
"fmt"
"io"
"mime/multipart"
"net/http"
"os"
)

func main() {
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
file, err := os.Open("photo.jpg")
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
part, _ := writer.CreateFormFile("forms_image_file", "photo.jpg")
io.Copy(part, file)
writer.WriteField("forms_ai_enabled", "1")
writer.Close()

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/ImageAssistant", body)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", writer.FormDataContentType())

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/ImageAssistant'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_ai_enabled': '1',
}
files = {
'forms_image_file': open('photo.jpg', 'rb'),
}

response = requests.post(url, data=payload, files=files, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/ImageAssistant")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form([["forms_image_file", File.open("photo.jpg")], ["forms_ai_enabled", "1"]], "multipart/form-data")

response = https.request(request)
puts response.read_body

{"message":"","result":{"text":"本日のおすすめ\n焼き魚定食 900円","tokens":[{"surface":"本日","lemma":"本日","reading":"ほんじつ","part_of_speech":"名詞","part_of_speech_english":"noun","is_symbol":false,"is_verb":false},{"surface":"の","lemma":"の","reading":"の","part_of_speech":"助詞","part_of_speech_english":"particle","is_symbol":false,"is_verb":false},{"surface":"おすすめ","lemma":"お勧め","reading":"おすすめ","part_of_speech":"名詞","part_of_speech_english":"noun","is_symbol":false,"is_verb":false}],"engine":"ai","notice":""}}

Turn text into speech

Japanese text read aloud at a pace matched to a JLPT level, the listening practice tool. The standard voice is included in every plan; the natural AI voice is optional.

Plan: every plan has a monthly allowance of texts to turn into speech (10, 25, 75, or 200 from the free plan up); each successful call counts as one, and the call answers 403 once the allowance is spent. The AI voice needs the Kanji plan or higher and spends one AI token per character. When your token allowance is used up the standard voice is used instead and notice says so.

Arguments

forms_text

required

string

The Japanese text. The limit depends on your plan: 50, 150, 500, or 1,500 characters from the free plan up; longer text answers 403.

forms_listening_practice_jlpt_level

required

string

The pace: one of N5, N4, N3, N2, N1, from slowest to natural speed.

forms_ai_enabled

optional

integer

1 for the natural AI voice, 0 (the default) for the standard voice.

Returns

An object with the audio as a base64 string, its mime_type and file extension, the engine that produced it (ai or openjtalk), and a notice when AI was requested but not used. Decode audio to get the audio file.

POST https://api.yomit.ai/v1/ListeningPractice

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_text=毎朝パンを食べる。" \
--data-urlencode "forms_listening_practice_jlpt_level=N4" \
--data-urlencode "forms_ai_enabled=0" \
https://api.yomit.ai/v1/ListeningPractice

<?php

$curl = curl_init();
$data = array(
'forms_text' => '毎朝パンを食べる。',
'forms_listening_practice_jlpt_level' => 'N4',
'forms_ai_enabled' => '0',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/ListeningPractice',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_text", "毎朝パンを食べる。")
data.Set("forms_listening_practice_jlpt_level", "N4")
data.Set("forms_ai_enabled", "0")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/ListeningPractice", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/ListeningPractice'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_text': '毎朝パンを食べる。',
'forms_listening_practice_jlpt_level': 'N4',
'forms_ai_enabled': '0',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/ListeningPractice")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_text" => "毎朝パンを食べる。", "forms_listening_practice_jlpt_level" => "N4", "forms_ai_enabled" => "0" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"audio":"UklGRiQAAABXQVZFZm10IBAAAAABAAEAgD4AAAB9AAACABAAZGF0YQAAAAA=","mime_type":"audio/wav","extension":"wav","engine":"openjtalk","notice":""}}

Make a writing practice sheet

A printable PDF with a practice block for every kanji, hiragana, and katakana in the text (readings and meanings, faded stroke order guides to trace, then empty writing squares), the writing practice tool. The optional arguments change the layout; leave them out for the standard sheet.

Plan: the number of different characters on one sheet grows with the plan (1, 3, 10, or 25 from the free plan up) and every plan has a monthly allowance of printed pages (10, 25, 75, or 200); a sheet counts as the pages it prints to, so three characters at one per page count as three and at three per page as one. The call answers 403 when the text has more characters than the plan allows or the sheet would not fit in the pages left. The layout arguments need the Kanji plan or higher; on the free plan they are ignored and the standard sheet is made.

The response body is the PDF file itself (Content-Type: application/pdf), not JSON. Errors are still JSON.

Arguments

forms_text

required

string

Text containing at most as many different kanji, hiragana, or katakana as the plan allows (1 to 25); every other character is ignored.

forms_writing_practice_page_size

optional

string

One of a4, letter. Default a4.

forms_writing_practice_kanji_per_page

optional

integer

One of 1, 2, 3. Default 1; with more than one the details are condensed and the tracing guides share the practice grid.

forms_writing_practice_box_size

optional

string

Size of the practice boxes, one of small, medium, large, extra_large (12, 10, 8, 6 boxes per row). Default medium.

forms_writing_practice_grid_style

optional

string

Guide lines inside each box, one of cross, star, plain. Default cross.

forms_writing_practice_trace_count

optional

integer

How many faded stroke order guides to trace, one of 0, 1, 2, 3, 4, 5. Default 5.

forms_writing_practice_guide_opacity

optional

string

How dark the tracing guides are, one of light, medium, dark. Default medium.

forms_writing_practice_detail_level

optional

string

How much to print about each kanji, one of none, basic, standard, full. basic is readings and main meanings, standard (the default) adds grade, JLPT level and frequency, full adds the radical, name readings and example words.

Returns

The PDF file.

GET https://api.yomit.ai/v1/WritingPractice

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_text=食べる" \
--data-urlencode "forms_writing_practice_box_size=large" \
--data-urlencode "forms_writing_practice_detail_level=full" \
-o practice.pdf \
https://api.yomit.ai/v1/WritingPractice

<?php

$curl = curl_init();
$data = array(
'forms_text' => '食べる',
'forms_writing_practice_box_size' => 'large',
'forms_writing_practice_detail_level' => 'full',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/WritingPractice?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

file_put_contents('practice.pdf', $response);

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"os"
)

func main() {
data := url.Values{}
data.Set("forms_text", "食べる")
data.Set("forms_writing_practice_box_size", "large")
data.Set("forms_writing_practice_detail_level", "full")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/WritingPractice?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
os.WriteFile("practice.pdf", data, 0644)
}

import requests

url = 'https://api.yomit.ai/v1/WritingPractice'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_text': '食べる',
'forms_writing_practice_box_size': 'large',
'forms_writing_practice_detail_level': 'full',
}

response = requests.get(url, params=params, headers=headers)
with open('practice.pdf', 'wb') as file:
file.write(response.content)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/WritingPractice")
url.query = URI.encode_www_form({ "forms_text" => "食べる", "forms_writing_practice_box_size" => "large", "forms_writing_practice_detail_level" => "full" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
File.binwrite("practice.pdf", response.body)

(the PDF file, Content-Type: application/pdf)

List your books

Your books with their pages, in the order you keep them in, plus how many notes are in each and the totals for the fixed views of My Notes (all, unfiled, linked).

Plan: every /Notes endpoint needs the Bunko plan or higher.

Returns

An object with books (each with id_note_book, title, description, position, note_count, and its pages) and counts.

GET https://api.yomit.ai/v1/Notes/Books

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Notes/Books

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Books',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Notes/Books", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Books'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

{"message":"","result":{"books":[{"id_note_book":"00000000-0000-4000-a000-000000000010","title":"JLPT N4","description":"Everything I am reviewing before the December test","position":0,"note_count":3,"pages":[{"id_note_page":"00000000-0000-4000-a000-000000000020","id_note_book":"00000000-0000-4000-a000-000000000010","title":"Verbs","position":0,"note_count":2},{"id_note_page":"00000000-0000-4000-a000-000000000021","id_note_book":"00000000-0000-4000-a000-000000000010","title":"Particles","position":1,"note_count":1}]}],"counts":{"all":5,"unfiled":2,"linked":3}}}

Create or rename a book

Create a book, which is added after your existing books, or change the title and description of one of your books.

Arguments

forms_note_book_title

required

string

The title, up to 255 characters.

forms_note_book_description

optional

string

A description, up to 1,000 characters.

forms_id_note_book

optional

uuid

The book to rename. Omit it to create a book.

Returns

The book: id_note_book, title, and description.

POST https://api.yomit.ai/v1/Notes/Books

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_note_book_title=JLPT N4" \
--data-urlencode "forms_note_book_description=Everything I am reviewing before the December test" \
https://api.yomit.ai/v1/Notes/Books

<?php

$curl = curl_init();
$data = array(
'forms_note_book_title' => 'JLPT N4',
'forms_note_book_description' => 'Everything I am reviewing before the December test',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Books',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_note_book_title", "JLPT N4")
data.Set("forms_note_book_description", "Everything I am reviewing before the December test")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Books", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Books'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_note_book_title': 'JLPT N4',
'forms_note_book_description': 'Everything I am reviewing before the December test',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Books")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_note_book_title" => "JLPT N4", "forms_note_book_description" => "Everything I am reviewing before the December test" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note_book":"00000000-0000-4000-a000-000000000010","title":"JLPT N4","description":"Everything I am reviewing before the December test"}}

Reorder your books

Save a new order for your books. Ids that are not yours are ignored and books missing from the list keep their place after the ones listed.

Arguments

forms_note_order

required

uuid list

The id_note_book values in their new order, separated by commas.

Returns

An object with the final order.

POST https://api.yomit.ai/v1/Notes/Books/Sort

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_note_order=00000000-0000-4000-a000-000000000010,00000000-0000-4000-a000-000000000011" \
https://api.yomit.ai/v1/Notes/Books/Sort

<?php

$curl = curl_init();
$data = array(
'forms_note_order' => '00000000-0000-4000-a000-000000000010,00000000-0000-4000-a000-000000000011',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Books/Sort',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_note_order", "00000000-0000-4000-a000-000000000010,00000000-0000-4000-a000-000000000011")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Books/Sort", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Books/Sort'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_note_order': '00000000-0000-4000-a000-000000000010,00000000-0000-4000-a000-000000000011',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Books/Sort")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_note_order" => "00000000-0000-4000-a000-000000000010,00000000-0000-4000-a000-000000000011" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"order":["00000000-0000-4000-a000-000000000010","00000000-0000-4000-a000-000000000011"]}}

Delete a book

Delete a book and its pages. The notes filed on those pages are not deleted, they become unfiled notes.

Arguments

forms_id_note_book

required

uuid

The book to delete.

Returns

An object with the deleted id_note_book.

POST https://api.yomit.ai/v1/Notes/Books/Delete

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note_book=00000000-0000-4000-a000-000000000010" \
https://api.yomit.ai/v1/Notes/Books/Delete

<?php

$curl = curl_init();
$data = array(
'forms_id_note_book' => '00000000-0000-4000-a000-000000000010',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Books/Delete',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_book", "00000000-0000-4000-a000-000000000010")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Books/Delete", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Books/Delete'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_id_note_book': '00000000-0000-4000-a000-000000000010',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Books/Delete")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_id_note_book" => "00000000-0000-4000-a000-000000000010" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note_book":"00000000-0000-4000-a000-000000000010"}}

Export a book

Download one of your books, with every page and note, as a PDF, Word, or Excel file.

The response body is the file itself, not JSON. Errors are still JSON.

Plan: the Sensei plan.

Arguments

forms_id_note_book

required

uuid

The book to export.

forms_note_export_format

required

string

One of pdf, docx, xlsx.

Returns

The file, with a Content-Disposition header carrying a file name based on the book's title.

GET https://api.yomit.ai/v1/Notes/Books/Export

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note_book=00000000-0000-4000-a000-000000000010" \
--data-urlencode "forms_note_export_format=pdf" \
-o book.pdf \
https://api.yomit.ai/v1/Notes/Books/Export

<?php

$curl = curl_init();
$data = array(
'forms_id_note_book' => '00000000-0000-4000-a000-000000000010',
'forms_note_export_format' => 'pdf',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Books/Export?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

file_put_contents('book.pdf', $response);

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"os"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_book", "00000000-0000-4000-a000-000000000010")
data.Set("forms_note_export_format", "pdf")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Notes/Books/Export?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
os.WriteFile("book.pdf", data, 0644)
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Books/Export'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_id_note_book': '00000000-0000-4000-a000-000000000010',
'forms_note_export_format': 'pdf',
}

response = requests.get(url, params=params, headers=headers)
with open('book.pdf', 'wb') as file:
file.write(response.content)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Books/Export")
url.query = URI.encode_www_form({ "forms_id_note_book" => "00000000-0000-4000-a000-000000000010", "forms_note_export_format" => "pdf" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
File.binwrite("book.pdf", response.body)

(the exported file, Content-Type: application/pdf)

Create or rename a page

Create a page at the end of a book, or rename one of your pages.

Arguments

forms_note_page_title

required

string

The title, up to 255 characters.

forms_id_note_book

optional

uuid

The book to add the page to. Required when creating a page.

forms_id_note_page

optional

uuid

The page to rename. Omit it to create a page.

Returns

The page: id_note_page, id_note_book, and title.

POST https://api.yomit.ai/v1/Notes/Pages

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note_book=00000000-0000-4000-a000-000000000010" \
--data-urlencode "forms_note_page_title=Verbs" \
https://api.yomit.ai/v1/Notes/Pages

<?php

$curl = curl_init();
$data = array(
'forms_id_note_book' => '00000000-0000-4000-a000-000000000010',
'forms_note_page_title' => 'Verbs',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Pages',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_book", "00000000-0000-4000-a000-000000000010")
data.Set("forms_note_page_title", "Verbs")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Pages", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Pages'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_id_note_book': '00000000-0000-4000-a000-000000000010',
'forms_note_page_title': 'Verbs',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Pages")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_id_note_book" => "00000000-0000-4000-a000-000000000010", "forms_note_page_title" => "Verbs" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note_page":"00000000-0000-4000-a000-000000000020","id_note_book":"00000000-0000-4000-a000-000000000010","title":"Verbs"}}

Reorder the pages of a book

Save a new order for the pages of one of your books.

Arguments

forms_id_note_book

required

uuid

The book whose pages are being reordered.

forms_note_order

required

uuid list

The id_note_page values in their new order, separated by commas.

Returns

An object with the id_note_book and the final order.

POST https://api.yomit.ai/v1/Notes/Pages/Sort

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note_book=00000000-0000-4000-a000-000000000010" \
--data-urlencode "forms_note_order=00000000-0000-4000-a000-000000000021,00000000-0000-4000-a000-000000000020" \
https://api.yomit.ai/v1/Notes/Pages/Sort

<?php

$curl = curl_init();
$data = array(
'forms_id_note_book' => '00000000-0000-4000-a000-000000000010',
'forms_note_order' => '00000000-0000-4000-a000-000000000021,00000000-0000-4000-a000-000000000020',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Pages/Sort',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_book", "00000000-0000-4000-a000-000000000010")
data.Set("forms_note_order", "00000000-0000-4000-a000-000000000021,00000000-0000-4000-a000-000000000020")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Pages/Sort", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Pages/Sort'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_id_note_book': '00000000-0000-4000-a000-000000000010',
'forms_note_order': '00000000-0000-4000-a000-000000000021,00000000-0000-4000-a000-000000000020',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Pages/Sort")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_id_note_book" => "00000000-0000-4000-a000-000000000010", "forms_note_order" => "00000000-0000-4000-a000-000000000021,00000000-0000-4000-a000-000000000020" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note_book":"00000000-0000-4000-a000-000000000010","order":["00000000-0000-4000-a000-000000000021","00000000-0000-4000-a000-000000000020"]}}

Delete a page

Delete a page. The notes filed on it are not deleted, they become unfiled notes.

Arguments

forms_id_note_page

required

uuid

The page to delete.

Returns

An object with the deleted id_note_page.

POST https://api.yomit.ai/v1/Notes/Pages/Delete

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note_page=00000000-0000-4000-a000-000000000020" \
https://api.yomit.ai/v1/Notes/Pages/Delete

<?php

$curl = curl_init();
$data = array(
'forms_id_note_page' => '00000000-0000-4000-a000-000000000020',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Pages/Delete',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_page", "00000000-0000-4000-a000-000000000020")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Pages/Delete", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Pages/Delete'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_id_note_page': '00000000-0000-4000-a000-000000000020',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Pages/Delete")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_id_note_page" => "00000000-0000-4000-a000-000000000020" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note_page":"00000000-0000-4000-a000-000000000020"}}

List your notes

Your notes, in one of four ways: the notes on a page (forms_id_note_page), the notes about one word, kanji, or grammar point (forms_note_reference_type and forms_note_reference_key), or one of the fixed views (forms_note_view). With no arguments every note is returned.

Arguments

forms_id_note_page

optional

uuid

The page whose notes to return, in their order on the page. The page itself is returned as page.

forms_note_reference_type

optional

string

With forms_note_reference_key, the kind of thing the notes are about: one of None, Word, Kanji, Grammar.

forms_note_reference_key

optional

string

The word (its written form), kanji, or grammar point id (id_japanese_grammar) the notes are about.

forms_note_view

optional

string

One of all, unfiled, linked, defaults to all. unfiled returns the notes not filed on any page, linked the notes about a word, kanji, or grammar point.

Returns

An object with notes, each with id_note, id_note_page (null when unfiled), dates, what it is about (reference_type, reference_key, reference_label), title, the markdown content, and content_html.

GET https://api.yomit.ai/v1/Notes

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note_page=00000000-0000-4000-a000-000000000020" \
https://api.yomit.ai/v1/Notes

<?php

$curl = curl_init();
$data = array(
'forms_id_note_page' => '00000000-0000-4000-a000-000000000020',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes?' . http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_page", "00000000-0000-4000-a000-000000000020")

req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Notes?"+data.Encode(), nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes'
headers = {'Authorization': 'Bearer abcdef1234567890'}
params = {
'forms_id_note_page': '00000000-0000-4000-a000-000000000020',
}

response = requests.get(url, params=params, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes")
url.query = URI.encode_www_form({ "forms_id_note_page" => "00000000-0000-4000-a000-000000000020" })

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"message":"","result":{"notes":[{"id_note":"00000000-0000-4000-a000-000000000030","id_note_page":"00000000-0000-4000-a000-000000000020","date_created":"2026-10-28 19:44:52","date_updated":"2026-10-28 19:44:52","reference_type":"Word","reference_key":"食べる","reference_label":"食べる (たべる)","title":"Eating verbs","content":"食べる is the polite everyday verb.\n\n- 食う (くう) is rougher, mostly used by men\n- 召し上がる (めしあがる) is the honorific form","content_html":"<p>食べる is the polite everyday verb.</p><ul><li>食う (くう) is rougher, mostly used by men</li><li>召し上がる (めしあがる) is the honorific form</li></ul>"}],"page":{"id_note_page":"00000000-0000-4000-a000-000000000020","id_note_book":"00000000-0000-4000-a000-000000000010","id_user":"00000000-0000-4000-a000-000000000099","date_created":"2026-10-28 19:44:52","date_updated":"2026-10-28 19:44:52","title":"Verbs","position":"0"}}}

Create or update a note

Write a note, or change the title, content, and page of one of your notes. A note can be about a word, kanji, or grammar point, so it shows up next to it in the dictionary and grammar pages; that link is fixed when the note is created. Content is markdown.

Arguments

forms_note_content

required

string

The note in markdown, up to 20,000 characters.

forms_note_title

optional

string

A title, up to 255 characters.

forms_id_note_page

optional

uuid

The page to file the note on. Omit it for an unfiled note. When updating, a different page moves the note to the end of that page.

forms_id_note

optional

uuid

The note to update. Omit it to create a note.

forms_note_reference_type

optional

string

When creating: what the note is about, one of None, Word, Kanji, Grammar. Defaults to None.

forms_note_reference_key

optional

string

Required with a reference type other than None: the word's written form, the kanji, or the grammar point's id_japanese_grammar.

forms_note_reference_label

optional

string

Required with a reference type other than None: how to show the linked item, for example 食べる (たべる).

Returns

The note, in the same shape as GET /Notes returns it.

POST https://api.yomit.ai/v1/Notes

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note_page=00000000-0000-4000-a000-000000000020" \
--data-urlencode "forms_note_title=Eating verbs" \
--data-urlencode "forms_note_content=食べる is the polite everyday verb." \
--data-urlencode "forms_note_reference_type=Word" \
--data-urlencode "forms_note_reference_key=食べる" \
--data-urlencode "forms_note_reference_label=食べる (たべる)" \
https://api.yomit.ai/v1/Notes

<?php

$curl = curl_init();
$data = array(
'forms_id_note_page' => '00000000-0000-4000-a000-000000000020',
'forms_note_title' => 'Eating verbs',
'forms_note_content' => '食べる is the polite everyday verb.',
'forms_note_reference_type' => 'Word',
'forms_note_reference_key' => '食べる',
'forms_note_reference_label' => '食べる (たべる)',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_page", "00000000-0000-4000-a000-000000000020")
data.Set("forms_note_title", "Eating verbs")
data.Set("forms_note_content", "食べる is the polite everyday verb.")
data.Set("forms_note_reference_type", "Word")
data.Set("forms_note_reference_key", "食べる")
data.Set("forms_note_reference_label", "食べる (たべる)")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_id_note_page': '00000000-0000-4000-a000-000000000020',
'forms_note_title': 'Eating verbs',
'forms_note_content': '食べる is the polite everyday verb.',
'forms_note_reference_type': 'Word',
'forms_note_reference_key': '食べる',
'forms_note_reference_label': '食べる (たべる)',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_id_note_page" => "00000000-0000-4000-a000-000000000020", "forms_note_title" => "Eating verbs", "forms_note_content" => "食べる is the polite everyday verb.", "forms_note_reference_type" => "Word", "forms_note_reference_key" => "食べる", "forms_note_reference_label" => "食べる (たべる)" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note":"00000000-0000-4000-a000-000000000030","id_note_page":"00000000-0000-4000-a000-000000000020","date_created":"2026-10-28 19:44:52","date_updated":"2026-10-28 19:44:52","reference_type":"Word","reference_key":"食べる","reference_label":"食べる (たべる)","title":"Eating verbs","content":"食べる is the polite everyday verb.","content_html":"<p>食べる is the polite everyday verb.</p>"}}

Reorder the notes on a page

Save a new order for the notes on one of your pages.

Arguments

forms_id_note_page

required

uuid

The page whose notes are being reordered.

forms_note_order

required

uuid list

The id_note values in their new order, separated by commas.

Returns

An object with the id_note_page and the final order.

POST https://api.yomit.ai/v1/Notes/Sort

<?php

$curl = curl_init();
$data = array(
'forms_id_note_page' => '00000000-0000-4000-a000-000000000020',
'forms_note_order' => '00000000-0000-4000-a000-000000000031,00000000-0000-4000-a000-000000000030',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Sort',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_id_note_page", "00000000-0000-4000-a000-000000000020")
data.Set("forms_note_order", "00000000-0000-4000-a000-000000000031,00000000-0000-4000-a000-000000000030")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Sort", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Sort'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_id_note_page': '00000000-0000-4000-a000-000000000020',
'forms_note_order': '00000000-0000-4000-a000-000000000031,00000000-0000-4000-a000-000000000030',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Sort")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_id_note_page" => "00000000-0000-4000-a000-000000000020", "forms_note_order" => "00000000-0000-4000-a000-000000000031,00000000-0000-4000-a000-000000000030" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note_page":"00000000-0000-4000-a000-000000000020","order":["00000000-0000-4000-a000-000000000031","00000000-0000-4000-a000-000000000030"]}}

Delete a note

Delete one of your notes.

Arguments

forms_id_note

required

uuid

The note to delete.

Returns

An object with the deleted id_note.

POST https://api.yomit.ai/v1/Notes/Delete

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_id_note=00000000-0000-4000-a000-000000000030" \
https://api.yomit.ai/v1/Notes/Delete

<?php

$curl = curl_init();
$data = array(
'forms_id_note' => '00000000-0000-4000-a000-000000000030',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/Delete',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_id_note", "00000000-0000-4000-a000-000000000030")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/Delete", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/Delete'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_id_note': '00000000-0000-4000-a000-000000000030',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/Delete")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_id_note" => "00000000-0000-4000-a000-000000000030" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"id_note":"00000000-0000-4000-a000-000000000030"}}

Use AI on your notes

The AI tools of My Notes, run over one note or over every note on a page: improve rewrites a single note with mistakes fixed and readings added (its content is returned, nothing is saved), summarize makes a revision sheet, quiz writes five questions with answers, and ask answers a question using the notes as context.

Plan: the Bunko plan or higher. Each call spends AI tokens from your monthly allowance.

Arguments

forms_note_ai_mode

required

string

One of improve, summarize, quiz, ask.

forms_id_note

optional

uuid

The note to work on. Required for improve; one of this or forms_id_note_page is required.

forms_id_note_page

optional

uuid

The page whose notes to work on together.

forms_note_ai_question

optional

string

The question for the ask mode, up to 1,000 characters.

Returns

An object with the mode, the answer as markdown, and the same answer rendered as html.

POST https://api.yomit.ai/v1/Notes/AI

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_note_ai_mode=quiz" \
--data-urlencode "forms_id_note_page=00000000-0000-4000-a000-000000000020" \
https://api.yomit.ai/v1/Notes/AI

<?php

$curl = curl_init();
$data = array(
'forms_note_ai_mode' => 'quiz',
'forms_id_note_page' => '00000000-0000-4000-a000-000000000020',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Notes/AI',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_note_ai_mode", "quiz")
data.Set("forms_id_note_page", "00000000-0000-4000-a000-000000000020")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Notes/AI", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Notes/AI'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_note_ai_mode': 'quiz',
'forms_id_note_page': '00000000-0000-4000-a000-000000000020',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Notes/AI")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_note_ai_mode" => "quiz", "forms_id_note_page" => "00000000-0000-4000-a000-000000000020" })

response = https.request(request)
puts response.read_body

{"message":"","result":{"mode":"quiz","markdown":"**Question 1**\nFill in the blank: 毎朝パン＿食べる。\n\n### Answers\n**1.** を — the object marker.","html":"<p><strong>Question 1</strong><br />Fill in the blank: 毎朝パン＿食べる。</p><h3>Answers</h3><p><strong>1.</strong> を — the object marker.</p>"}}

Get your account

The account behind the token: your display name and email address, your plan and what it includes, and for plans with AI how much of this billing cycle's token allowance you have used, day by day.

Returns

An object with id_user, date_created, name, username, plan, plan_price, plan_currency, the features your plan includes (ai, notes, note_export), ai_usage (null without AI), and ai_usage_daily.

GET https://api.yomit.ai/v1/Account

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Account

import requests

url = 'https://api.yomit.ai/v1/Account'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

{"message":"","result":{"id_user":"00000000-0000-4000-a000-000000000099","date_created":"2026-10-28 19:44:52","name":"Paxton","username":"paxton@example.com","plan":"Bunko","plan_price":"7.99","plan_currency":"USD","features":{"ai":true,"notes":true,"note_export":false},"ai_usage":{"plan":"3","limit":500000,"used":41200,"remaining":458800,"percent":8,"cycle_start":"2026-10-16 19:44:52","cycle_end":"2026-11-15 19:44:52","id_user_plan":"00000000-0000-4000-a000-000000000002"},"ai_usage_daily":[{"id_user":"00000000-0000-4000-a000-000000000099","date_created":"2026-10-28","request_count":"6","tokens_prompt":"4100","tokens_completion":"2900","tokens_total":"7000"}]}}

Change your display name

Change the name shown in the site's header and in your notes exports.

Arguments

forms_display_name

required

string

The new display name.

Returns

An object with the new name.

POST https://api.yomit.ai/v1/Account

curl -X POST \
-H "Authorization: Bearer abcdef1234567890" \
--data-urlencode "forms_display_name=Paxton" \
https://api.yomit.ai/v1/Account

<?php

$curl = curl_init();
$data = array(
'forms_display_name' => 'Paxton',
);

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Account',
CURLOPT_POST => true,
CURLOPT_POSTFIELDS => http_build_query($data),
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
"net/url"
"strings"
)

func main() {
data := url.Values{}
data.Set("forms_display_name", "Paxton")

req, err := http.NewRequest("POST", "https://api.yomit.ai/v1/Account", strings.NewReader(data.Encode()))
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")
req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Account'
headers = {'Authorization': 'Bearer abcdef1234567890'}
payload = {
'forms_display_name': 'Paxton',
}

response = requests.post(url, data=payload, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Account")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Post.new(url)
request["Authorization"] = "Bearer abcdef1234567890"
request.set_form_data({ "forms_display_name" => "Paxton" })

response = https.request(request)
puts response.read_body

{"message":"Your display name has been updated","result":{"name":"Paxton"}}

Get your plan

The plan currently associated with your account along with its monthly price.

Returns

An object with the plan name (Kana, Kanji, Bunko, Sensei), the monthly plan_price for your account including any price override, and the ISO 4217 plan_currency.

GET https://api.yomit.ai/v1/Plan

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Plan

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Plan',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Plan", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Plan'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Plan")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"result":{"plan":"Kana","plan_price":"0.00","plan_currency":"USD"}}

List your payments

Every payment on your account in summary form: when it was made, the amount, and its id.

Returns

An array of payment objects, each with id_payment, date_created, and payment_total.

GET https://api.yomit.ai/v1/Payments

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Payments

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Payments',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Payments", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Payments'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Payments")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"result":[{"id_payment":"00000000-0000-4000-a000-000000000001","date_created":"2026-10-28 19:44:52","payment_total":"7.99"},{"id_payment":"00000000-0000-4000-a000-000000000000","date_created":"2026-09-28 19:44:52","payment_total":"7.99"}]}

Get a payment

The details of one payment: billing address, masked card details, and the plan that was paid for.

Arguments

{PAYMENT_ID}

required

uuid

The id of the payment, from /Payments, as the last part of the path.

Returns

A payment object.

GET https://api.yomit.ai/v1/Payments/{PAYMENT_ID}

curl -G \
-H "Authorization: Bearer abcdef1234567890" \
https://api.yomit.ai/v1/Payments/00000000-0000-4000-a000-000000000001

<?php

$curl = curl_init();

curl_setopt_array($curl, array(
CURLOPT_URL => 'https://api.yomit.ai/v1/Payments/00000000-0000-4000-a000-000000000001',
CURLOPT_RETURNTRANSFER => true,
CURLOPT_HTTPHEADER => array(
'Authorization: Bearer abcdef1234567890'
)
));

$response = curl_exec($curl);
curl_close($curl);

echo $response;

package main

import (
"fmt"
"io"
"net/http"
)

func main() {
req, err := http.NewRequest("GET", "https://api.yomit.ai/v1/Payments/00000000-0000-4000-a000-000000000001", nil)
if err != nil {
fmt.Println(err)
return
}
req.Header.Add("Authorization", "Bearer abcdef1234567890")

res, err := http.DefaultClient.Do(req)
if err != nil {
fmt.Println(err)
return
}
defer res.Body.Close()

data, _ := io.ReadAll(res.Body)
fmt.Println(string(data))
}

import requests

url = 'https://api.yomit.ai/v1/Payments/00000000-0000-4000-a000-000000000001'
headers = {'Authorization': 'Bearer abcdef1234567890'}

response = requests.get(url, headers=headers)
print(response.text)

require "uri"
require "net/http"

url = URI("https://api.yomit.ai/v1/Payments/00000000-0000-4000-a000-000000000001")

https = Net::HTTP.new(url.host, url.port)
https.use_ssl = (url.scheme == "https")

request = Net::HTTP::Get.new(url)
request["Authorization"] = "Bearer abcdef1234567890"

response = https.request(request)
puts response.read_body

{"result":{"id_payment":"00000000-0000-4000-a000-000000000001","date_created":"2026-10-28 19:44:52","billing_first_name":"Paxton","billing_last_name":"Smith","billing_address_1":"12 Avenue Avenue","billing_address_2":"Suite 200","billing_country":"CA","billing_province_state":"ON","billing_city":"Toronto","billing_zip_postal_code":"A1B2C3","billing_phone":"4165551234","payment_total":"7.99","card_type":"Visa","card_masked_number":"**** 1111","plan":"Bunko"}}

forms_collection

Which dictionary collection /Dictionary/Collection returns. Accepted values:

body: Body

clock: Clock

colours: Colours

connectors: Connectors

counters: Counters

demonstratives: Demonstratives

family: Family

feelings: Feelings

frequency: Frequency

house: House

numbers: Numbers

position: Position

questions: Questions

time: Time

weather: Weather

forms_listening_practice_jlpt_level

The pace of /ListeningPractice, slowest to fastest. Accepted values:

N5: N5 - Slowest

N4: N4 - Slow

N3: N3 - Relaxed

N2: N2 - Natural

N1: N1 - Fast

forms_grammar_level

A JLPT level for /Grammar. Accepted values:

n5: JLPT N5

n4: JLPT N4

n3: JLPT N3

n2: JLPT N2

n1: JLPT N1

forms_note_reference_type

What a note is about. Accepted values:

None: None

Word: Word

Kanji: Kanji

Grammar: Grammar

forms_note_view

A fixed view of GET /Notes. Accepted values:

all: All notes

unfiled: Unfiled

linked: Linked to dictionary and grammar

forms_note_ai_mode

What /Notes/AI should do. Accepted values:

improve: Improve this note

summarize: Summarize

quiz: Quiz me

ask: Ask a question

forms_note_export_format

The file type of /Notes/Books/Export. Accepted values:

pdf: PDF

docx: Word (.docx)

xlsx: Excel (.xlsx)