واجهة API العامة v1

مرجع واجهة القاموس للقراءة فقط، مولَّد من مستند OpenAPI الذي ينشره الخادم — العقد نفسه الذي تُبنى منه حزم SDK.

Read-only dictionary API under /api/v1 (contract version 1): no authentication, every answer in a { data, meta } envelope, errors as { statusCode, message, error: true }, X-API-Version on every response. The /api/compat/freedictionaryapi/v1 routes use freedictionaryapi.com objects, language lists and plain-text errors. The /api/compat/dictionaryapi routes use dictionaryapi.dev v1/v2 arrays and errors, with additive vocabBloom provenance. Compatibility lookups ending in /datasets wrap the responses from all installed datasets in { data, meta }; each group has dataset terms, status and response. Successful GET answers carry ETag, Last-Modified and Cache-Control. Documentation: https://vocab-bloom-hub.com/en/docs/api.

عنوان URL الأساسيhttps://<instance>/api/v1

تقدّم كل نسخة واجهة API تحت أصلها الخاص؛ تستخدم الأمثلة أدناه عنوانًا بديلًا.

العقد

مستند OpenAPI 3، تقدّمه كل نسخة على المسار /api/v1/openapi.json; الملف المُودَع في المستودع

نقاط النهاية

GET/api/v1/meta

API and dataset versions, data license and counts of the served dictionary

المعاملات

لا معاملات.

الاستجابات

200OK — PublicMetaV1ResT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/meta'

const res = await fetch('https://your-instance.example/api/v1/meta');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/meta")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/meta")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/meta');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/meta"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/meta"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/meta')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.meta();
console.log(data.available_languages, data.counts.entries);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
meta = client.meta()
print(meta.data.available_languages, meta.data.counts.entries)

جرّبها في ساحة التجربة

GET/api/v1/openapi.json

The OpenAPI 3 document of the public API (this contract)

المعاملات

لا معاملات.

الاستجابات

200OK — object
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT
503Not available: a selected dataset could not be read, the OpenAPI document is not ready, or the suggestion queue is full — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/openapi.json'

const res = await fetch('https://your-instance.example/api/v1/openapi.json');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/openapi.json")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/openapi.json")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/openapi.json');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/openapi.json"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/openapi.json"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/openapi.json')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const document = await client.openapi();
const info = document.info;
if (info && typeof info === 'object' && 'version' in info) {
  console.log(info.version);
}

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
document = client.openapi()
print(document["info"]["version"])

GET/api/v1/search

Search dictionary entries (flat list, no meanings)

Tiers in relevance order: exact, phrasal, starts-with, phrases, ends-with, contains. When none matches, a trigram similarity tier answers typos (`meta.fuzzy: true`, `similarity` on every item; Postgres instances only). A term shorter than 3 characters searches the exact and prefix tiers only (`meta.short_term: true`). Cacheable: the answer carries `ETag`, `Last-Modified` and `Cache-Control` like every public GET.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`search`	query	`string`	نعم	The term to search for
`type`	query	`string` `wordgrammar_patternphrase`	لا	Restrict the answer to one entry type
`limit`	query	`integer`	لا	الافتراضي: 10
`dataset`	query	`string`	لا	Public dataset name; omitted = the active dataset. Unknown or closed targets return 404, never a fallback.

الاستجابات

200OK — PublicSearchV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT
503Not available: a selected dataset could not be read, the OpenAPI document is not ready, or the suggestion queue is full — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/search'

const res = await fetch('https://your-instance.example/api/v1/search');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/search")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/search")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/search');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/search"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/search"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/search')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data, meta } = await client.search({ search: 'run' });
console.log(meta.fuzzy, data[0]?.word);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.search("run")
print(answer.meta.fuzzy, answer.data[0].word if answer.data else None)

جرّبها في ساحة التجربة

GET/api/v1/search/detailed

Search dictionary entries with pagination, meanings and translations

The detailed search: the same term and tiers, paged, with meanings and translations joined on request; the fields travel in the query string (`translation_languages` as a repeated key). Cacheable like every public GET.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`search`	query	`string`	نعم	The term to search for
`type`	query	`string` `wordgrammar_patternphrase`	لا	Restrict the answer to one entry type
`limit`	query	`integer`	لا	الافتراضي: 10
`page`	query	`integer`	لا	الافتراضي: 1
`with_meanings`	query	`boolean`	لا	Join the meanings (with translations, synonyms, antonyms) of every item الافتراضي: false
`with_translations`	query	`boolean`	لا	Join the short translations of every item الافتراضي: false
`translation_languages`	query	`string[]` `ruesfrdeptzhar`	لا	Keep only these translation languages (a repeated key); omit the key for all of them
`dataset`	query	`string`	لا	Public dataset name; omitted = the active dataset. Unknown or closed targets return 404, never a fallback.

الاستجابات

200OK — PublicSearchDetailedV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT
503Not available: a selected dataset could not be read, the OpenAPI document is not ready, or the suggestion queue is full — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/search/detailed'

const res = await fetch('https://your-instance.example/api/v1/search/detailed');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/search/detailed")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/search/detailed")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/search/detailed');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/search/detailed"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/search/detailed"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/search/detailed')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.searchDetailed({ search: 'run', with_meanings: true });
const first = data[0];
console.log(first?.part_of_speech, first?.meanings?.[0]?.title);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.search_detailed("run", with_meanings=True)
first = answer.data[0] if answer.data else None
print(
    first.part_of_speech.value if first else None,
    first.meanings[0].title if first and first.meanings else None,
)

جرّبها في ساحة التجربة

GET/api/v1/words/{word}

All entries of a headword: parts of speech, forms, meanings, translations, links

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — PublicHeadwordV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run'

const res = await fetch('https://your-instance.example/api/v1/words/run');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.word('run');
console.log(data[0]?.meanings?.[0]?.definition);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.word("run")
first = answer.data[0] if answer.data else None
print(first.meanings[0].definition if first and first.meanings else None)

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/meanings

The meanings of a headword across its entries

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — PublicHeadwordMeaningsV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/meanings'

const res = await fetch('https://your-instance.example/api/v1/words/run/meanings');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/meanings")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/meanings")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/meanings');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/meanings"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/meanings"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/meanings')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.meanings('run');
console.log(data[0]?.definition);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.meanings("run")
print(answer.data[0].definition if answer.data else None)

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/translations

The short and per-meaning translations of a headword

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry
`language`	query	`string[]` `ruesfrdeptzhar`	لا	Translation languages; no value means all of them

الاستجابات

200OK — PublicHeadwordTranslationsV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/translations'

const res = await fetch('https://your-instance.example/api/v1/words/run/translations');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/translations")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/translations")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/translations');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/translations"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/translations"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/translations')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.translations('run');
const first = data.meaning_translations[0];
console.log(first?.title, first?.language);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.translations("run")
first = answer.data.meaning_translations[0] if answer.data.meaning_translations else None
print(first.title if first else None, first.language.value if first else None)

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/forms

The inflected forms of a headword across its entries

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — PublicHeadwordFormsV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/forms'

const res = await fetch('https://your-instance.example/api/v1/words/run/forms');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/forms")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/forms")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/forms');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/forms"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/forms"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/forms')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.forms('run');
for (const form of data) {
  console.log(form.word, form.form_of_word);
}

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.forms("run")
for form in answer.data:
    print(form.word, form.form_of_word.value)

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/synonyms

The synonyms of a headword, per meaning

One item per linked headword and meaning; each names its `meaning_id`, `word_id` and `part_of_speech`.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — PublicHeadwordLinksV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/synonyms'

const res = await fetch('https://your-instance.example/api/v1/words/run/synonyms');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/synonyms")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/synonyms")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/synonyms');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/synonyms"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/synonyms"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/synonyms')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.synonyms('run');
console.log(data.map((link) => link.word));

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.synonyms("run")
print([link.word for link in answer.data])

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/antonyms

The antonyms of a headword, per meaning

One item per linked headword and meaning; each names its `meaning_id`, `word_id` and `part_of_speech`.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — PublicHeadwordLinksV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/antonyms'

const res = await fetch('https://your-instance.example/api/v1/words/run/antonyms');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/antonyms")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/antonyms")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/antonyms');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/antonyms"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/antonyms"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/antonyms')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.antonyms('run');
console.log(data.map((link) => link.word));

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.antonyms("run")
print([link.word for link in answer.data])

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/history

What was changed or added on the instance in the entries of a headword

The edits that still show in what is served, the latest first, with the values before and after: the entries of such a headword carry `modified: true`. Empty for a headword served as its source has it.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — PublicHeadwordHistoryV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/history'

const res = await fetch('https://your-instance.example/api/v1/words/run/history');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/history")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/history")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/history');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/history"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/history"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/history')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/datasets

A headword as every open dataset of the instance has it, grouped by dataset

One group per open dataset, never merged: the terms of the dataset (`license`, `attribution`, `license_text`, …) and the entries `GET /words/{word}` would answer if that dataset were the served one. The spelling is matched inside each dataset, so a group has its own `word` and `variants`; a dataset without the headword answers an empty `entries`, and the request fails with 404 when no dataset holds it. Entries taken from several groups are bound by the terms of each. One request against the rate limit.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — PublicWordDatasetsV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/datasets'

const res = await fetch('https://your-instance.example/api/v1/words/run/datasets');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/datasets")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/datasets")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/datasets');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/datasets"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/datasets"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/datasets')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data, meta } = await client.wordDatasets('run');
console.log(`${meta.found} of ${meta.datasets} datasets hold the word`);
for (const group of data) {
  // the entries of a group are used under the terms of that group
  console.log(group.dataset, group.license, group.attribution, group.entries.length);
}

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.word_datasets("run")
print(f"{answer.meta.found} of {answer.meta.datasets} datasets hold the word")
for group in answer.data:
    # the entries of a group are used under the terms of that group
    print(group.dataset, group.license, group.attribution, len(group.entries))

جرّبها في ساحة التجربة

GET/api/v1/words/{word}/datasets/{dataset}/history

What was changed or added on the instance in the entries of a headword, in one dataset

The answer of `GET /words/{word}/history` for a dataset named by its `dataset`: the edits behind `modified: true` of the entries of that group. 404 for a closed dataset or a dataset the instance does not hold.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry
`dataset`	path	`string`	نعم	The name of a dataset of the instance, as `dataset` of a group of `GET /words/{word}/datasets` says it

الاستجابات

200OK — PublicHeadwordHistoryV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/run/datasets/default/history'

const res = await fetch('https://your-instance.example/api/v1/words/run/datasets/default/history');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/run/datasets/default/history")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/run/datasets/default/history")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/run/datasets/default/history');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/run/datasets/default/history"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/run/datasets/default/history"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/run/datasets/default/history')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.datasetHistory('run', 'default');
for (const change of data) {
  console.log(change.created_at, change.entity, change.action, change.diff);
}

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
history = client.dataset_history("run", "default")
for change in history.data:
    print(change.created_at, change.entity.value, change.action.value, change.diff)

جرّبها في ساحة التجربة

GET/api/v1/words/id/{id}

One dictionary entry by its numeric id

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`id`	path	`number`	نعم

الاستجابات

200OK — PublicWordV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words/id/1'

const res = await fetch('https://your-instance.example/api/v1/words/id/1');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words/id/1")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words/id/1")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/id/1');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words/id/1"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/id/1"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/id/1')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.wordById(1);
console.log(data.word, data.part_of_speech);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.word_by_id(1)
print(answer.data.word, answer.data.part_of_speech.value)

جرّبها في ساحة التجربة

GET/api/v1/words

List dictionary entries by filters, cursor-paged and ordered by (word, id)

Every enum filter accepts a repeated key; values of one filter are OR-ed, filters are AND-ed. `search` keeps the headwords starting with the prefix (an autocomplete or an A–Z browser: cacheable, unlike the search). Pass `meta.next_cursor` back as `cursor` to read the next page.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`search`	query	`string`	لا	Headword prefix, case-insensitive (`ru` lists run, rung, runner, …)
`is_obsolete`	query	`boolean`	لا	true: obsolete entries only, false: current ones only
`part_of_speech`	query	`string[]` `nounverbmodal_verbadjectiveadverbpronounnumeralnumeral_fractionaldeterminerinterjectionarticleprepositionconjunctionletterphrasegrammar_pattern`	لا
`word_level`	query	`string[]` `A1A2B1B2C1C2`	لا
`language_register`	query	`string[]` `formalinformalslang`	لا
`category`	query	`string[]` `scientifictechnicalmedicallegalbusinessITartpoliticalsportculinary`	لا	Words tagged with any of the categories
`area_variant`	query	`string[]` `commonbritishamericanaustralian`	لا
`form_of_word`	query	`string[]` `base_formplural_formpossessive_singular_formpossessive_plural_formpast_simplepast_participlepresent_participlethird_person_singularcomparative_formsuperlative_formobjectpossessive_adjectivepossessive_pronounreflexiveordinalmultiplicative`	لا	Defaults to base forms only الافتراضي: ["base_form"]
`cursor`	query	`string`	لا	The `meta.next_cursor` of the previous page; omit for the first page
`limit`	query	`integer`	لا	الافتراضي: 20
`with_meanings`	query	`boolean`	لا	Join the meanings of every word الافتراضي: false
`with_translations`	query	`boolean`	لا	Join the short translations of every word الافتراضي: false

الاستجابات

200OK — PublicWordsV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/words'

const res = await fetch('https://your-instance.example/api/v1/words');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/words")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/words")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/words"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.words({ word_level: ['A1'] });
console.log(data.slice(0, 5).map((entry) => entry.word));

// To read every matching entry across all pages:
// for await (const entry of client.iterateWords({ word_level: ['A1'] })) {
//   console.log(entry.word);
// }

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.words(word_level=["A1"])
print([entry.word for entry in answer.data[:5]])

# To read every matching entry across all pages:
# for entry in client.iter_words(word_level=["A1"]):
#     print(entry.word)

جرّبها في ساحة التجربة

GET/api/v1/random

A random dictionary entry matching the filters (base forms unless form_of_word is given)

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`search`	query	`string`	لا	Headword prefix, case-insensitive (`ru` lists run, rung, runner, …)
`is_obsolete`	query	`boolean`	لا	true: obsolete entries only, false: current ones only
`part_of_speech`	query	`string[]` `nounverbmodal_verbadjectiveadverbpronounnumeralnumeral_fractionaldeterminerinterjectionarticleprepositionconjunctionletterphrasegrammar_pattern`	لا
`word_level`	query	`string[]` `A1A2B1B2C1C2`	لا
`language_register`	query	`string[]` `formalinformalslang`	لا
`category`	query	`string[]` `scientifictechnicalmedicallegalbusinessITartpoliticalsportculinary`	لا	Words tagged with any of the categories
`area_variant`	query	`string[]` `commonbritishamericanaustralian`	لا
`form_of_word`	query	`string[]` `base_formplural_formpossessive_singular_formpossessive_plural_formpast_simplepast_participlepresent_participlethird_person_singularcomparative_formsuperlative_formobjectpossessive_adjectivepossessive_pronounreflexiveordinalmultiplicative`	لا	Defaults to base forms only الافتراضي: ["base_form"]

الاستجابات

200OK — PublicWordV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/random'

const res = await fetch('https://your-instance.example/api/v1/random');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/random")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/random")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/random');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/random"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/random"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/random')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.random();
console.log(data.word);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.random()
print(answer.data.word)

جرّبها في ساحة التجربة

GET/api/v1/search/semantic/status

Whether the instance enables semantic search

Reflects only SEMANTIC_SEARCH_ENABLED. Performs no inference and does not promise model/vector availability. Never cached.

المعاملات

لا معاملات.

الاستجابات

200OK — PublicSemanticStatusV1ResT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/search/semantic/status'

const res = await fetch('https://your-instance.example/api/v1/search/semantic/status');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/search/semantic/status")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/search/semantic/status")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/search/semantic/status');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/search/semantic/status"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/search/semantic/status"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/search/semantic/status')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.semanticStatus();
console.log(data.enabled);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.semantic_status()
print(answer.data.enabled)

جرّبها في ساحة التجربة

GET/api/v1/search/semantic

Find existing meanings from a description

Separate from spelling search; no lexical fallback. Requires SEMANTIC_SEARCH_ENABLED, PostgreSQL/pgvector, imported current vectors and a matching Ollama model. Disabled = 404 semantic_search_disabled; missing infrastructure, busy service or incompatible model = 503. Returns up to 20 meanings, ordered by cosine similarity then meaning ID. Scores are not confidence probabilities; no calibrated no-answer threshold. No pagination or cross-dataset ranking. Uses the shared public rate budget. Responses are no-store.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`query`	query	`string`	نعم	A description of the intended meaning, in English or another language supported by the model.
`dataset`	query	`string`	لا	One public dataset; omitted = active dataset. Closed/unknown targets return 404.
`limit`	query	`integer`	لا	الافتراضي: 10

الاستجابات

200OK — PublicSemanticSearchV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT
503Not available: a selected dataset could not be read, the OpenAPI document is not ready, or the suggestion queue is full — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/search/semantic'

const res = await fetch('https://your-instance.example/api/v1/search/semantic');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/search/semantic")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/search/semantic")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/search/semantic');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/search/semantic"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/search/semantic"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/search/semantic')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.searchSemantic({ query: 'A scientist who studies birds' });
console.log(data[0]?.word.word, data[0]?.meaning.definition);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.search_semantic("A scientist who studies birds")
print(answer.data[0].meaning.definition if answer.data else None)

جرّبها في ساحة التجربة

GET/api/compat/dictionaryapi/v2/entries/{language}/{word}/datasets

dictionaryapi.dev v2 responses from every open dataset

One group per installed dataset with its terms, status and response in the adapter format. Missing words have status 404 and the adapter error in response. The outer request returns 200 even when no dataset matches. English only; the usual headword and inflection rules apply in each dataset. No query parameters. Does not activate any dataset. One public rate-limit unit; cached across all datasets.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`language`	path	`string` `enen_USen_GB`	نعم
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — DictionaryApiV2DatasetsResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — DictionaryApiErrorT
404Nothing matches — DictionaryApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — DictionaryApiErrorT

مثال

curl 'https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets'

const res = await fetch('https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run/datasets')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/compat/dictionaryapi/v1/entries/{language}/{word}/datasets

dictionaryapi.dev v1 responses from every open dataset

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`language`	path	`string` `enen_USen_GB`	نعم
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — DictionaryApiV1DatasetsResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — DictionaryApiErrorT
404Nothing matches — DictionaryApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — DictionaryApiErrorT

مثال

curl 'https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets'

const res = await fetch('https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run/datasets')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/compat/freedictionaryapi/v1/entries/{language}/{word}/datasets

freedictionaryapi.com responses from every open dataset

One group per installed dataset with its terms, status 200 and the adapter object in response. Exact spelling; en and all read English. Missing words and other languages have empty response.entries. The outer request returns 200 even when no dataset matches. Does not activate any dataset. One public rate-limit unit; cached across all datasets. Empty source links point here rather than active-only /meta.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`language`	path	`string`	نعم	en or all; other values return empty entries
`word`	path	`string`	نعم	Exact case-sensitive spelling, encoded as one URL segment
`pretty`	query	`boolean`	لا	Indent the whole response with two spaces; default false.
`translations`	query	`boolean`	لا	Include supported translations; default false. Only true/false, first occurrence wins.

الاستجابات

200OK — FreeDictionaryDatasetsResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window

مثال

curl 'https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets'

const res = await fetch('https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run/datasets')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/compat/dictionaryapi/v2/entries/{language}/{word}

dictionaryapi.dev v2 lookup in the active dataset

Array response, with lossless provenance in vocabBloom. English only; native headword and inflection resolution. No dataset query parameter.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`language`	path	`string` `enen_USen_GB`	نعم
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — DictionaryApiV2ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — DictionaryApiErrorT
404Nothing matches — DictionaryApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — DictionaryApiErrorT

مثال

curl 'https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run'

const res = await fetch('https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/compat/dictionaryapi/v2/entries/en/run')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/compat/dictionaryapi/v1/entries/{language}/{word}

dictionaryapi.dev legacy v1 lookup in the active dataset

Same entries and terms as v2, with a meaning object keyed by part of speech instead of meanings. English only.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`language`	path	`string` `enen_USen_GB`	نعم
`word`	path	`string`	نعم	Headword spelling, case-insensitive (spaces URL-encoded for phrases). An inflected form resolves to its base entry

الاستجابات

200OK — DictionaryApiV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — DictionaryApiErrorT
404Nothing matches — DictionaryApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — DictionaryApiErrorT

مثال

curl 'https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run'

const res = await fetch('https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/compat/dictionaryapi/v1/entries/en/run')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/compat/freedictionaryapi/v1/entries/{language}/{word}

freedictionaryapi.com lookup in the active dataset

Exact spelling. en and all read the English database; other languages and missing spellings return empty entries. Full terms in vocabBloom.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`language`	path	`string`	نعم	en or all; other values return empty entries
`word`	path	`string`	نعم	Exact case-sensitive spelling, encoded as one URL segment
`pretty`	query	`boolean`	لا	Indent JSON with two spaces; default false.
`translations`	query	`boolean`	لا	Include supported translations; default false. Only true/false, first occurrence wins.

الاستجابات

200OK — FreeDictionaryEntriesResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window

مثال

curl 'https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run'

const res = await fetch('https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/compat/freedictionaryapi/v1/entries/example/run')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/compat/freedictionaryapi/v1/languages

Available headword languages and readable spelling counts

English only. Counts include phrases, inflections and alternative-only entry rows in the active dataset, once per readable spelling; unlinked placeholders are excluded.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`pretty`	query	`boolean`	لا	Indent JSON with two spaces; default false.

الاستجابات

200OK — FreeDictionaryLanguagesResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window

مثال

curl 'https://your-instance.example/api/compat/freedictionaryapi/v1/languages'

const res = await fetch('https://your-instance.example/api/compat/freedictionaryapi/v1/languages');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/compat/freedictionaryapi/v1/languages")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/compat/freedictionaryapi/v1/languages")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/compat/freedictionaryapi/v1/languages');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/compat/freedictionaryapi/v1/languages"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/compat/freedictionaryapi/v1/languages"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/compat/freedictionaryapi/v1/languages')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

جرّبها في ساحة التجربة

GET/api/v1/search/datasets

Search up to five public datasets, in separate groups

Repeat datasets for each target (1–5 unique names). Groups follow installation order. The detailed search filters, limit (1–20) and page (1–20) apply independently to every group. Relevance scores are local to each dataset. Empty matches have status ok and an empty data array; failed readers have status unavailable and no results/pagination. Unknown or closed targets reject the entire request with 404. Partial failures return 200 with meta.partial and Cache-Control: no-store. Each selected dataset costs one unit of the shared public rate budget, including failed reads. Selected searches revalidate their ETag on every use.

المعاملات

الاسم	الموضع	النوع	مطلوب	الوصف
`search`	query	`string`	نعم	The term to search for
`type`	query	`string` `wordgrammar_patternphrase`	لا	Restrict the answer to one entry type
`limit`	query	`integer`	لا	الافتراضي: 10
`page`	query	`integer`	لا	الافتراضي: 1
`with_meanings`	query	`boolean`	لا	Join the meanings (with translations, synonyms, antonyms) of every item الافتراضي: false
`with_translations`	query	`boolean`	لا	Join the short translations of every item الافتراضي: false
`translation_languages`	query	`string[]` `ruesfrdeptzhar`	لا	Keep only these translation languages (a repeated key); omit the key for all of them
`datasets`	query	`string[]`	نعم	Public dataset names as repeated keys. Groups follow installation order. Each selected dataset costs one unit of the shared public rate budget.

الاستجابات

200OK — PublicSearchDatasetsV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/search/datasets?search=run&datasets=default'

const res = await fetch('https://your-instance.example/api/v1/search/datasets?search=run&datasets=default');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/search/datasets?search=run&datasets=default")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/search/datasets?search=run&datasets=default")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/search/datasets?search=run&datasets=default');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/search/datasets?search=run&datasets=default"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/search/datasets?search=run&datasets=default"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/search/datasets?search=run&datasets=default')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.searchDatasets({ search: 'run', datasets: ['default'] });
for (const group of data) {
  if (group.status === 'ok') console.log(group.dataset, group.data, group.meta.has_more);
  else console.log(group.dataset, group.error);
}

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
from vocab_bloom_hub import SearchDatasetResult
answer = client.search_datasets("run", ["default"])
for group in answer.data:
    if isinstance(group, SearchDatasetResult):
        print(group.dataset, group.data, group.meta.has_more)
    else:
        print(group.dataset, group.error)

جرّبها في ساحة التجربة

GET/api/v1/datasets

Publicly readable datasets and their terms, in installation order

المعاملات

لا معاملات.

الاستجابات

200OK — PublicDatasetsV1ResT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl 'https://your-instance.example/api/v1/datasets'

const res = await fetch('https://your-instance.example/api/v1/datasets');
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.get("https://your-instance.example/api/v1/datasets")
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
)

resp, err := http.Get("https://your-instance.example/api/v1/datasets")
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/datasets');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let answer: Value = client
        .get(r#"https://your-instance.example/api/v1/datasets"#)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/datasets"))
            .GET()
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/datasets')
request = Net::HTTP::Get.new(uri)
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.datasets();
console.log(data.map(dataset => dataset.dataset));

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.datasets()
print([dataset.dataset for dataset in answer.data])

جرّبها في ساحة التجربة

POST/api/v1/words/batch

Up to 50 headwords in one request

Every spelling is matched like `GET /words/{word}`; the answer keeps the request order, collapses duplicates, and lists the spellings without an entry under `meta.not_found` instead of failing. One request against the rate limit, whatever the size of the batch.

جسم الطلب · `WordsBatchV1ReqDTO`

الاسم	النوع	مطلوب	الوصف
`words`	`string[]`	نعم	Headword spellings, 50 at most, each matched like GET /words/{word} (case-insensitively; an inflected form resolves to its base entry)

الاستجابات

200OK — PublicWordsBatchV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT

مثال

curl -X POST 'https://your-instance.example/api/v1/words/batch' \
  -H 'Content-Type: application/json' \
  -d '{"words":["run","walk","nonexistentword"]}'

const res = await fetch('https://your-instance.example/api/v1/words/batch', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    words: ['run', 'walk', 'nonexistentword']
  }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.post("https://your-instance.example/api/v1/words/batch", json={
  "words": ["run", "walk", "nonexistentword"]
})
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
	"strings"
)

resp, err := http.Post("https://your-instance.example/api/v1/words/batch", "application/json", strings.NewReader(`{"words":["run","walk","nonexistentword"]}`))
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/words/batch');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS => json_encode([
      'words' => ['run', 'walk', 'nonexistentword']
    ]),
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let body: Value = serde_json::from_str(r#"{"words":["run","walk","nonexistentword"]}"#)?;
    let answer: Value = client
        .post(r#"https://your-instance.example/api/v1/words/batch"#)
        .json(&body)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/words/batch"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("{\"words\":[\"run\",\"walk\",\"nonexistentword\"]}"))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/words/batch')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = JSON.generate({
  'words' => ['run', 'walk', 'nonexistentword']
})
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data, meta } = await client.wordsBatch(['run', 'walk', 'nonexistentword']);
console.log(data.map((item) => item.word), meta.not_found);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.words_batch(["run", "walk", "nonexistentword"])
print([item.word for item in answer.data], answer.meta.not_found)

جرّبها في ساحة التجربة

POST/api/v1/suggestions

Report a mistake in the dictionary data

Files a report for the instance admin to review: what is wrong with a headword (optionally one specific entry of it) and, ideally, what would be right. The headword must exist in the selected publicly open dataset. Pass dataset to target a viewed dataset; omitted means the active dataset. All IDs must belong to that dataset and headword. Closed, unknown or removed targets answer 404 without fallback. Rate limits are shared across datasets; a full target queue answers 503.

جسم الطلب · `CreateSuggestionV1ReqDTO`

الاسم	النوع	مطلوب	الوصف
`dataset`	`string`	لا	Installed, publicly open dataset containing the headword and all supplied IDs. Omit to use the active dataset.
`headword`	`string`	نعم	The headword the report is about; must exist in the dictionary
`word_id`	`object`	لا	Id of the entry (part of speech) the report points at, from the word answers
`kind`	`string` `reportedit`	لا	الافتراضي: "report"
`message`	`object`	لا	What is wrong and, ideally, what would be right. Required for a report; an optional comment on an edit
`edits`	`SuggestionEditV1DTO[]`	لا	Edit flow: every touched target of the word form with its proposed values
`author_name`	`object`	لا	The name the sender wants to be credited by (issue #531). Kept only together with `author_consent: true`: once the correction is applied the name is shown next to it and travels with the copies of the data
`author_consent`	`object`	لا	The sender agrees that `author_name` is shown and exported; required when a name is given

الاستجابات

201OK — PublicSuggestionCreatedV1ResT
400Invalid input: an unknown field, a value outside the allowed set, or a foreign cursor — PublicApiErrorT
404Nothing matches — PublicApiErrorT
429Rate limit of the public prefix exceeded (PUBLIC_API_RATE_LIMIT); retry after the window — PublicApiErrorT
503Not available: a selected dataset could not be read, the OpenAPI document is not ready, or the suggestion queue is full — PublicApiErrorT

مثال

curl -X POST 'https://your-instance.example/api/v1/suggestions' \
  -H 'Content-Type: application/json' \
  -d '{"headword":"run","message":"Please check the definition of this word."}'

const res = await fetch('https://your-instance.example/api/v1/suggestions', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    headword: 'run',
    message: 'Please check the definition of this word.'
  }),
});
if (!res.ok) throw new Error(`HTTP ${res.status}`);
const answer = await res.json();

import requests

res = requests.post("https://your-instance.example/api/v1/suggestions", json={
  "headword": "run",
  "message": "Please check the definition of this word."
})
res.raise_for_status()
answer = res.json()

import (
	"encoding/json"
	"log"
	"net/http"
	"strings"
)

resp, err := http.Post("https://your-instance.example/api/v1/suggestions", "application/json", strings.NewReader(`{"headword":"run","message":"Please check the definition of this word."}`))
if err != nil {
	log.Fatal(err)
}
defer resp.Body.Close()

var answer map[string]any
if err := json.NewDecoder(resp.Body).Decode(&answer); err != nil {
	log.Fatal(err)
}

$ch = curl_init('https://your-instance.example/api/v1/suggestions');
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
    CURLOPT_POSTFIELDS => json_encode([
      'headword' => 'run',
      'message' => 'Please check the definition of this word.'
    ]),
]);
$answer = json_decode(curl_exec($ch), true);
curl_close($ch);

// cargo add reqwest --features blocking,json
// cargo add serde_json
use reqwest::blocking::Client;
use serde_json::Value;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let body: Value = serde_json::from_str(r#"{"headword":"run","message":"Please check the definition of this word."}"#)?;
    let answer: Value = client
        .post(r#"https://your-instance.example/api/v1/suggestions"#)
        .json(&body)
        .send()?
        .error_for_status()?
        .json()?;
    println!("{answer}");
    Ok(())
}

import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class Main {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://your-instance.example/api/v1/suggestions"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString("{\"headword\":\"run\",\"message\":\"Please check the definition of this word.\"}"))
            .build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

require 'net/http'
require 'json'

uri = URI('https://your-instance.example/api/v1/suggestions')
request = Net::HTTP::Post.new(uri)
request['Content-Type'] = 'application/json'
request.body = JSON.generate({
  'headword' => 'run',
  'message' => 'Please check the definition of this word.'
})
response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
  http.request(request)
end
response.value
answer = JSON.parse(response.body)
puts JSON.pretty_generate(answer)

import { VocabBloomClient } from '@vocab-bloom-hub/client';

const client = new VocabBloomClient({ baseUrl: 'https://your-instance.example' });
const { data } = await client.suggest({
  headword: 'run',
  message: 'Please check the definition of this word.'
});
console.log(data.id, data.status);

from vocab_bloom_hub import VocabBloomClient

client = VocabBloomClient("https://your-instance.example")
answer = client.suggest(**{
  "headword": "run",
  "message": "Please check the definition of this word."
})
print(answer.data.id, answer.data.status)

جرّبها في ساحة التجربة

المخططات

SuggestionEditV1DTO

الاسم	النوع	مطلوب	الوصف
`target_type`	`string` `wordmeaningmeaning_translationshort_translation`	نعم
`target_id`	`number`	نعم	Id of the targeted row, from the word answers
`changes`	`object`	نعم	The proposed field values, e.g. { "definition": "…" }. The accepted fields depend on target_type; unknown fields, empty values and values equal to the current ones are rejected

CreateSuggestionV1ReqDTO

الاسم	النوع	مطلوب	الوصف
`dataset`	`string`	لا	Installed, publicly open dataset containing the headword and all supplied IDs. Omit to use the active dataset.
`headword`	`string`	نعم	The headword the report is about; must exist in the dictionary
`word_id`	`object`	لا	Id of the entry (part of speech) the report points at, from the word answers
`kind`	`string` `reportedit`	لا	الافتراضي: "report"
`message`	`object`	لا	What is wrong and, ideally, what would be right. Required for a report; an optional comment on an edit
`edits`	`SuggestionEditV1DTO[]`	لا	Edit flow: every touched target of the word form with its proposed values
`author_name`	`object`	لا	The name the sender wants to be credited by (issue #531). Kept only together with `author_consent: true`: once the correction is applied the name is shown next to it and travels with the copies of the data
`author_consent`	`object`	لا	The sender agrees that `author_name` is shown and exported; required when a name is given

WordsBatchV1ReqDTO

الاسم	النوع	مطلوب	الوصف
`words`	`string[]`	نعم	Headword spellings, 50 at most, each matched like GET /words/{word} (case-insensitively; an inflected form resolves to its base entry)

PublicSearchV1MetaT

الاسم	النوع	مطلوب	الوصف
`dataset`	`string`	لا	Present only for an explicitly selected dataset.
`count`	`integer`	نعم
`fuzzy`	`boolean`	نعم
`short_term`	`boolean`	نعم

PublicSearchV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicSearchWordV1T[]`	نعم
`meta`	`PublicSearchV1MetaT`	نعم

PublicSearchWordV1T

الاسم	النوع	مطلوب	الوصف
`alternatives`	`string[]`	لا	Alternative spellings of this headword, shared by all its parts of speech.
`origins`	`OriginT[]`	لا
`contributions`	`OriginT[]`	لا	Terms of the datasets whose edits still contribute to this word.
`licenses`	`WordLicenseT[]`	لا
`id`	`integer`	نعم
`word`	`string`	نعم
`part_of_speech`	`EnPartOfSpeechE`	نعم
`form_of_word`	`EnWordFormsE`	نعم
`is_obsolete`	`boolean`	نعم
`is_abbreviation`	`boolean`	نعم
`word_level`	`WordLevelE \| null`	نعم
`area_variant`	`EnAreaVariantsE \| null`	نعم
`categories`	`CategoryE[]`	نعم
`language_register`	`LanguageRegisterE \| null`	نعم
`description`	`string \| null`	نعم
`transcription`	`string \| null`	نعم
`pronunciations`	`PronunciationT[]`	لا	Ordered pronunciations, with legacy transcription and base-form fallback.
`pattern`	`string[] \| null`	نعم
`noun___irregular_plural`	`boolean \| null`	نعم
`noun___uncountable`	`boolean \| null`	نعم
`noun___is_proper`	`boolean \| null`	نعم
`noun___always_plural`	`boolean \| null`	نعم
`verb___is_irregular`	`boolean \| null`	نعم
`verb___transitivity`	`EnVerbTransitivityE \| null`	نعم
`verb___is_phrasal`	`boolean \| null`	نعم
`verb___phrasal_object_pattern`	`EnPhrasalObjectPatternE \| null`	نعم
`base_phrasal`	`string \| null`	نعم
`forms`	`PublicWordV1FormT[]`	نعم
`similarity`	`number`	لا
`source`	`string`	لا
`modified`	`boolean`	لا

OriginT

الاسم	النوع	مطلوب	الوصف
`id`	`string`	نعم
`name`	`string`	نعم
`version`	`string \| null`	نعم
`url`	`string`	لا
`record_url`	`string`	لا
`licenses`	`OriginLicenseT[]`	نعم
`license_relation`	`string` `allany`	نعم	All obligations apply, or the source explicitly offers a choice.
`attribution`	`string`	نعم
`notices`	`string[]`	نعم
`scope`	`string` `worddataset`	نعم	Dataset means that distribution between individual words is unknown.
`method`	`string` `datasetmanual`	نعم
`recorded_at`	`string \| null`	نعم
`acquisitions`	`OriginAcquisitionT[]`	لا	Copy/fork events belonging to this source snapshot; absent before any acquisition.
`inherited`	`boolean`	نعم	Automatically inherited terms cannot be removed by ordinary editing.

OriginLicenseT

A durable statement of terms, not a pointer to a mutable dataset registry.

الاسم	النوع	مطلوب	الوصف
`spdx`	`string`	لا
`name`	`string`	نعم
`url`	`string`	نعم
`text`	`string`	لا	Required for custom licenses; preserved verbatim when supplied.

OriginAcquisitionT

An acquisition of a source snapshot, without repeating its license terms.

الاسم	النوع	مطلوب	الوصف
`id`	`string`	نعم
`method`	`string` `copyfork`	نعم
`recorded_at`	`string \| null`	نعم
`revision`	`string`	لا
`via`	`object`	لا	The intermediate dataset the material passed through; this adds no license obligations.

WordLicenseT

One license can occur more than once; origin_id refers to origins or contributions.

الاسم	النوع	مطلوب	الوصف
`origin_id`	`string`	نعم
`spdx`	`string`	لا
`name`	`string`	نعم
`url`	`string`	نعم
`text`	`string`	لا	Required for custom licenses; preserved verbatim when supplied.

EnPartOfSpeechE

واحد من: noun, verb, modal_verb, adjective, adverb, pronoun, numeral, numeral_fractional, determiner, interjection, article, preposition, conjunction, letter, phrase, grammar_pattern

EnWordFormsE

واحد من: base_form, plural_form, possessive_singular_form, possessive_plural_form, past_simple, past_participle, present_participle, third_person_singular, comparative_form, superlative_form, object, possessive_adjective, possessive_pronoun, reflexive, ordinal, multiplicative

WordLevelE

واحد من: A1, A2, B1, B2, C1, C2

EnAreaVariantsE

واحد من: common, british, american, australian

CategoryE

واحد من: scientific, technical, medical, legal, business, IT, art, political, sport, culinary

LanguageRegisterE

واحد من: formal, informal, slang

PronunciationT

Portable pronunciation; database IDs never travel in datasets or public responses.

الاسم	النوع	مطلوب	الوصف
`audio`	`PronunciationAudioT[]`	لا	Recordings carry their own terms, independent of the word's text.
`type`	`string` `ipaenpr`	نعم
`text`	`string \| null`	نعم
`area_variant`	`EnAreaVariantsE`	نعم
`sort_order`	`integer`	نعم

PronunciationAudioT

External recordings only; missing license metadata is an empty list, never the text license.

الاسم	النوع	مطلوب
`url`	`string`	نعم
`source_url`	`string \| null`	لا
`attribution`	`string \| null`	لا
`licenses`	`OriginLicenseT[]`	نعم
`sort_order`	`integer`	نعم

EnVerbTransitivityE

واحد من: transitive, intransitive, both

EnPhrasalObjectPatternE

واحد من: no_object, inseparable, separable, separable_pronoun_only

PublicWordV1FormT

الاسم	النوع	مطلوب	الوصف
`alternatives`	`string[]`	لا
`id`	`integer`	نعم
`word`	`string`	نعم
`form_of_word`	`EnWordFormsE`	نعم
`area_variant`	`EnAreaVariantsE`	نعم
`transcription`	`string \| null`	نعم
`pronunciations`	`PronunciationT[]`	لا	Ordered pronunciations, with legacy transcription and base-form fallback.

PublicSearchDetailedV1MetaT

الاسم	النوع	مطلوب	الوصف
`dataset`	`string`	لا	Present only for an explicitly selected dataset.
`page`	`integer`	نعم
`limit`	`integer`	نعم
`has_more`	`boolean`	نعم
`fuzzy`	`boolean`	نعم
`short_term`	`boolean`	نعم

PublicSearchDetailedV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordV1T[]`	نعم
`meta`	`PublicSearchDetailedV1MetaT`	نعم

PublicWordV1T

الاسم	النوع	مطلوب	الوصف
`etymologies`	`object[]`	لا
`meanings`	`PublicWordV1MeaningT[]`	نعم
`short_translations`	`PublicWordV1ShortTranslationT[]`	نعم
`phrasal_variants`	`string[]`	لا
`alternatives`	`string[]`	لا	Alternative spellings of this headword, shared by all its parts of speech.
`origins`	`OriginT[]`	لا
`contributions`	`OriginT[]`	لا	Terms of the datasets whose edits still contribute to this word.
`licenses`	`WordLicenseT[]`	لا
`id`	`integer`	نعم
`word`	`string`	نعم
`part_of_speech`	`EnPartOfSpeechE`	نعم
`form_of_word`	`EnWordFormsE`	نعم
`is_obsolete`	`boolean`	نعم
`is_abbreviation`	`boolean`	نعم
`word_level`	`WordLevelE \| null`	نعم
`area_variant`	`EnAreaVariantsE \| null`	نعم
`categories`	`CategoryE[]`	نعم
`language_register`	`LanguageRegisterE \| null`	نعم
`description`	`string \| null`	نعم
`transcription`	`string \| null`	نعم
`pronunciations`	`PronunciationT[]`	لا	Ordered pronunciations, with legacy transcription and base-form fallback.
`pattern`	`string[] \| null`	نعم
`noun___irregular_plural`	`boolean \| null`	نعم
`noun___uncountable`	`boolean \| null`	نعم
`noun___is_proper`	`boolean \| null`	نعم
`noun___always_plural`	`boolean \| null`	نعم
`verb___is_irregular`	`boolean \| null`	نعم
`verb___transitivity`	`EnVerbTransitivityE \| null`	نعم
`verb___is_phrasal`	`boolean \| null`	نعم
`verb___phrasal_object_pattern`	`EnPhrasalObjectPatternE \| null`	نعم
`base_phrasal`	`string \| null`	نعم
`forms`	`PublicWordV1FormT[]`	نعم
`similarity`	`number`	لا
`source`	`string`	لا
`modified`	`boolean`	لا

PublicWordV1MeaningT

الاسم	النوع	مطلوب	الوصف
`etymology_number`	`integer \| null`	لا	Local number of the owning word etymology; null when unknown.
`id`	`integer`	نعم
`sort_order`	`integer`	نعم
`title`	`string`	نعم
`definition`	`string`	نعم
`is_obsolete`	`boolean`	نعم
`examples`	`string[]`	نعم
`quotes`	`MeaningQuoteT[]`	لا
`categories`	`CategoryE[]`	نعم
`meaning_level`	`WordLevelE \| null`	نعم
`area_variant`	`EnAreaVariantsE`	نعم
`language_register`	`LanguageRegisterE \| null`	نعم
`translations`	`PublicWordV1MeaningTranslationT[]`	نعم
`synonyms`	`string[]`	نعم
`antonyms`	`string[]`	نعم

MeaningQuoteT

A sourced quotation, in authored array order. Missing attribution is explicit.

الاسم	النوع	مطلوب
`text`	`string`	نعم
`reference`	`string \| null`	نعم
`source_url`	`string \| null`	لا

PublicWordV1MeaningTranslationT

الاسم	النوع	مطلوب
`id`	`integer`	نعم
`language`	`AvailableTranslationLanguagesE`	نعم
`title`	`string`	نعم
`definition`	`string`	نعم
`variants_of_words`	`string[]`	نعم

AvailableTranslationLanguagesE

واحد من: ru, es, fr, de, pt, zh, ar

PublicWordV1ShortTranslationT

الاسم	النوع	مطلوب
`id`	`integer`	نعم
`language`	`AvailableTranslationLanguagesE`	نعم
`description`	`string`	نعم
`variants_of_words`	`string[]`	نعم

PublicWordV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordV1T`	نعم

PublicHeadwordV1MetaT

الاسم	النوع	مطلوب
`word`	`string`	نعم
`count`	`integer`	نعم
`variants`	`string[]`	لا

PublicHeadwordV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordV1T[]`	نعم
`meta`	`PublicHeadwordV1MetaT`	نعم

PublicMeaningV1T

الاسم	النوع	مطلوب	الوصف
`origins`	`OriginT[]`	لا
`contributions`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`word_id`	`integer`	نعم
`part_of_speech`	`EnPartOfSpeechE`	نعم
`source`	`string`	لا
`modified`	`boolean`	لا
`etymology_number`	`integer \| null`	لا	Local number of the owning word etymology; null when unknown.
`id`	`integer`	نعم
`sort_order`	`integer`	نعم
`title`	`string`	نعم
`definition`	`string`	نعم
`is_obsolete`	`boolean`	نعم
`examples`	`string[]`	نعم
`quotes`	`MeaningQuoteT[]`	لا
`categories`	`CategoryE[]`	نعم
`meaning_level`	`WordLevelE \| null`	نعم
`area_variant`	`EnAreaVariantsE`	نعم
`language_register`	`LanguageRegisterE \| null`	نعم
`translations`	`PublicWordV1MeaningTranslationT[]`	نعم
`synonyms`	`string[]`	نعم
`antonyms`	`string[]`	نعم

PublicHeadwordMeaningsV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicMeaningV1T[]`	نعم
`meta`	`PublicHeadwordV1MetaT`	نعم

PublicWordFormV1T

الاسم	النوع	مطلوب	الوصف
`origins`	`OriginT[]`	لا
`contributions`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`word_id`	`integer`	نعم
`part_of_speech`	`EnPartOfSpeechE`	نعم
`source`	`string`	لا
`modified`	`boolean`	لا
`alternatives`	`string[]`	لا
`id`	`integer`	نعم
`word`	`string`	نعم
`form_of_word`	`EnWordFormsE`	نعم
`area_variant`	`EnAreaVariantsE`	نعم
`transcription`	`string \| null`	نعم
`pronunciations`	`PronunciationT[]`	لا	Ordered pronunciations, with legacy transcription and base-form fallback.

PublicHeadwordFormsV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordFormV1T[]`	نعم
`meta`	`PublicHeadwordV1MetaT`	نعم

PublicShortTranslationV1T

الاسم	النوع	مطلوب
`origins`	`OriginT[]`	لا
`contributions`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`word_id`	`integer`	نعم
`part_of_speech`	`EnPartOfSpeechE`	نعم
`source`	`string`	لا
`modified`	`boolean`	لا
`id`	`integer`	نعم
`language`	`AvailableTranslationLanguagesE`	نعم
`description`	`string`	نعم
`variants_of_words`	`string[]`	نعم

PublicMeaningTranslationV1T

الاسم	النوع	مطلوب
`meaning_id`	`integer`	نعم
`origins`	`OriginT[]`	لا
`contributions`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`word_id`	`integer`	نعم
`part_of_speech`	`EnPartOfSpeechE`	نعم
`source`	`string`	لا
`modified`	`boolean`	لا
`id`	`integer`	نعم
`language`	`AvailableTranslationLanguagesE`	نعم
`title`	`string`	نعم
`definition`	`string`	نعم
`variants_of_words`	`string[]`	نعم

PublicWordLinkV1T

الاسم	النوع	مطلوب
`meaning_id`	`integer`	نعم
`word`	`string`	نعم
`origins`	`OriginT[]`	لا
`contributions`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`word_id`	`integer`	نعم
`part_of_speech`	`EnPartOfSpeechE`	نعم
`source`	`string`	لا
`modified`	`boolean`	لا

PublicHeadwordLinksV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordLinkV1T[]`	نعم
`meta`	`PublicHeadwordV1MetaT`	نعم

PublicChangeV1T

الاسم	النوع	مطلوب	الوصف
`inherited_from`	`OriginT \| null`	لا
`contribution`	`OriginT \| null`	لا	Terms captured when this edit was made, independent of later dataset changes.
`reason`	`string \| null`	لا
`created_at`	`string`	نعم
`word`	`string`	نعم
`part_of_speech`	`string \| null`	نعم
`entity`	`ChangeEntityE`	نعم
`action`	`ChangeActionE`	نعم
`record`	`ChangeRecordT \| null`	نعم
`diff`	`ChangeDiffT`	نعم
`origin`	`ChangeOriginE`	نعم
`author`	`string \| null`	نعم
`source`	`string`	لا

ChangeEntityE

What was edited

واحد من: word, word_form, meaning, meaning_translation, short_translation

ChangeActionE

واحد من: create, update, delete

ChangeRecordT

The record of an entry an edit is about, by what it says rather than by its id: ids change when a dataset is updated and differ between instances. Null for the word itself — the headword and the part of speech name it.

الاسم	النوع	مطلوب	الوصف

ChangeFormRecordT

الاسم	النوع	مطلوب	الوصف
`word`	`string`	نعم
`form_of_word`	`string`	نعم

ChangeMeaningRecordT

الاسم	النوع	مطلوب	الوصف
`title`	`string`	نعم
`sort_order`	`integer`	نعم

ChangeTranslationRecordT

الاسم	النوع	مطلوب
`meaning`	`ChangeMeaningRecordT`	نعم
`language`	`string`	نعم
`title`	`string`	نعم

ChangeShortTranslationRecordT

الاسم	النوع	مطلوب	الوصف
`language`	`string`	نعم
`description`	`string`	نعم

ChangeDiffT

The values an edit changed: `{ field: { before, after } }`; a creation has no `before`, a deletion no `after`

الاسم	النوع	مطلوب	الوصف

ChangeOriginE

Where an edit came from

واحد من: admin, suggestion, revert

PublicHeadwordHistoryV1MetaT

الاسم	النوع	مطلوب
`word`	`string`	نعم
`count`	`integer`	نعم
`variants`	`string[]`	لا

PublicHeadwordHistoryV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicChangeV1T[]`	نعم
`meta`	`PublicHeadwordHistoryV1MetaT`	نعم

PublicDatasetTermsV1T

الاسم	النوع	مطلوب
`origins`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`description`	`string \| null`	لا
`dataset`	`string`	نعم
`title`	`string`	لا
`active`	`boolean`	نعم
`source`	`string`	نعم
`dataset_version`	`string \| null`	نعم
`license`	`string`	نعم
`license_url`	`string`	نعم
`attribution`	`string`	نعم
`attribution_url`	`string \| null`	نعم
`notice`	`string`	نعم
`license_text`	`string`	نعم

PublicWordDatasetV1T

الاسم	النوع	مطلوب
`word`	`string`	نعم
`variants`	`string[]`	نعم
`count`	`integer`	نعم
`entries`	`PublicWordV1T[]`	نعم
`origins`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`description`	`string \| null`	لا
`dataset`	`string`	نعم
`title`	`string`	لا
`active`	`boolean`	نعم
`source`	`string`	نعم
`dataset_version`	`string \| null`	نعم
`license`	`string`	نعم
`license_url`	`string`	نعم
`attribution`	`string`	نعم
`attribution_url`	`string \| null`	نعم
`notice`	`string`	نعم
`license_text`	`string`	نعم

PublicWordDatasetsV1MetaT

الاسم	النوع	مطلوب
`word`	`string`	نعم
`datasets`	`integer`	نعم
`found`	`integer`	نعم

PublicWordDatasetsV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordDatasetV1T[]`	نعم
`meta`	`PublicWordDatasetsV1MetaT`	نعم

PublicHeadwordTranslationsV1T

الاسم	النوع	مطلوب	الوصف
`short_translations`	`PublicShortTranslationV1T[]`	نعم
`meaning_translations`	`PublicMeaningTranslationV1T[]`	نعم

PublicHeadwordTranslationsV1ResT

الاسم	النوع	مطلوب	الوصف
`meta`	`PublicHeadwordV1MetaT`	نعم
`data`	`PublicHeadwordTranslationsV1T`	نعم

PublicWordsBatchItemV1T

الاسم	النوع	مطلوب
`word`	`string`	نعم
`count`	`integer`	نعم
`entries`	`PublicWordV1T[]`	نعم

PublicWordsBatchV1MetaT

الاسم	النوع	مطلوب	الوصف
`count`	`integer`	نعم
`not_found`	`string[]`	نعم

PublicWordsBatchV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordsBatchItemV1T[]`	نعم
`meta`	`PublicWordsBatchV1MetaT`	نعم

PublicWordsV1MetaT

الاسم	النوع	مطلوب
`limit`	`integer`	نعم
`has_more`	`boolean`	نعم
`next_cursor`	`string \| null`	نعم

PublicWordsV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicWordV1T[]`	نعم
`meta`	`PublicWordsV1MetaT`	نعم

PublicDatasetCountsV1T

الاسم	النوع	مطلوب
`entries`	`integer`	نعم
`words`	`integer`	نعم
`phrases`	`integer`	نعم
`grammar_patterns`	`integer`	نعم
`word_forms`	`integer`	نعم
`meanings`	`integer`	نعم
`meaning_translations`	`integer`	نعم
`short_translations`	`integer`	نعم

PublicMetaV1T

الاسم	النوع	مطلوب
`origins`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`description`	`string \| null`	لا
`api_version`	`string`	نعم
`app_version`	`string`	نعم
`dataset_version`	`string \| null`	نعم
`license`	`string`	نعم
`license_url`	`string`	نعم
`attribution`	`string`	نعم
`notice`	`string`	نعم
`dataset`	`string`	لا
`title`	`string`	لا
`source`	`string`	لا
`attribution_url`	`string \| null`	لا
`license_text`	`string`	لا
`modified_entries`	`integer`	لا
`counts`	`PublicDatasetCountsV1T`	نعم
`available_languages`	`PublicAvailableLanguagesV1T`	نعم

PublicAvailableLanguagesV1T

الاسم	النوع	مطلوب	الوصف
`source`	`string[]`	نعم
`translations`	`AvailableTranslationLanguagesE[]`	نعم

PublicMetaV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicMetaV1T`	نعم

PublicSuggestionCreatedV1T

الاسم	النوع	مطلوب	الوصف
`id`	`integer`	نعم
`status`	`string`	نعم

PublicSuggestionCreatedV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicSuggestionCreatedV1T`	نعم

PublicApiErrorT

الاسم	النوع	مطلوب
`statusCode`	`number`	نعم
`message`	`string`	نعم
`error`	`boolean`	نعم

DictionaryApiV1DatasetsResT

الاسم	النوع	مطلوب	الوصف
`data`	`object[]`	نعم
`meta`	`object`	نعم	found counts datasets with entries, including for adapters whose misses are HTTP 200.

DictionaryApiV1ResT

الاسم	النوع	مطلوب	الوصف

DictionaryApiDefinitionT

الاسم	النوع	مطلوب
`definition`	`string`	نعم
`example`	`string`	لا
`synonyms`	`string[]`	نعم
`antonyms`	`string[]`	نعم

DictionaryApiPhoneticT

الاسم	النوع	مطلوب	الوصف
`text`	`string`	لا
`audio`	`string`	نعم
`sourceUrl`	`string`	لا
`license`	`DictionaryApiLicenseT`	لا
`vocabBloom`	`object`	لا	Lossless recording terms; the upstream singular license cannot express all of these.

DictionaryApiLicenseT

الاسم	النوع	مطلوب	الوصف
`name`	`string`	نعم
`url`	`string`	نعم

DictionaryApiErrorT

الاسم	النوع	مطلوب
`title`	`string`	نعم
`message`	`string`	نعم
`resolution`	`string`	نعم

DictionaryApiV2DatasetsResT

الاسم	النوع	مطلوب	الوصف
`data`	`object[]`	نعم
`meta`	`object`	نعم	found counts datasets with entries, including for adapters whose misses are HTTP 200.

DictionaryApiV2ResT

الاسم	النوع	مطلوب	الوصف

DictionaryApiMeaningT

الاسم	النوع	مطلوب
`partOfSpeech`	`string`	نعم
`definitions`	`DictionaryApiDefinitionT[]`	نعم
`synonyms`	`string[]`	نعم
`antonyms`	`string[]`	نعم

FreeDictionaryDatasetsResT

الاسم	النوع	مطلوب	الوصف
`data`	`object[]`	نعم
`meta`	`object`	نعم	found counts datasets with entries, including for adapters whose misses are HTTP 200.

FreeDictionaryEntriesResT

الاسم	النوع	مطلوب	الوصف
`word`	`string`	نعم
`entries`	`FreeDictionaryEntryT[]`	نعم
`source`	`object`	نعم
`vocabBloom`	`PublicDatasetTermsV1T`	نعم	Terms of the dataset read. Word-specific origins are retained on each entry.

FreeDictionaryEntryT

الاسم	النوع	مطلوب	الوصف
`language`	`FreeDictionaryLanguageT`	نعم
`partOfSpeech`	`string`	نعم
`pronunciations`	`object[]`	نعم
`forms`	`object[]`	نعم
`senses`	`FreeDictionarySenseT[]`	نعم
`synonyms`	`string[]`	نعم
`antonyms`	`string[]`	نعم
`vocabBloom`	`object`	نعم	Native entry identity and lossless terms; additive to the upstream format.

FreeDictionaryLanguageT

الاسم	النوع	مطلوب	الوصف
`code`	`string`	نعم
`name`	`string`	نعم

FreeDictionarySenseT

الاسم	النوع	مطلوب
`definition`	`string`	نعم
`tags`	`string[]`	نعم
`examples`	`string[]`	نعم
`quotes`	`object[]`	نعم
`synonyms`	`string[]`	نعم
`antonyms`	`string[]`	نعم
`translations`	`object[]`	لا
`subsenses`	`FreeDictionarySenseT[]`	نعم

FreeDictionaryErrorT

Upstream parameter errors are plain text, not the native error envelope.

الاسم	النوع	مطلوب	الوصف

FreeDictionaryLanguagesResT

الاسم	النوع	مطلوب	الوصف

PublicDatasetsV1ResT

Public selector inventory, in installation order; no dictionary connections or counts.

الاسم	النوع	مطلوب	الوصف
`data`	`PublicDatasetTermsV1T[]`	نعم
`meta`	`object`	نعم

PublicSearchDatasetResultV1T

الاسم	النوع	مطلوب
`status`	`string` `ok`	نعم
`data`	`PublicWordV1T[]`	نعم
`meta`	`PublicSearchDetailedV1MetaT`	نعم
`origins`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`description`	`string \| null`	لا
`dataset`	`string`	نعم
`title`	`string`	لا
`active`	`boolean`	نعم
`source`	`string`	نعم
`dataset_version`	`string \| null`	نعم
`license`	`string`	نعم
`license_url`	`string`	نعم
`attribution`	`string`	نعم
`attribution_url`	`string \| null`	نعم
`notice`	`string`	نعم
`license_text`	`string`	نعم

PublicSearchDatasetUnavailableV1T

A failed reader has no result list or paging metadata; it is not an empty match.

الاسم	النوع	مطلوب
`status`	`string` `unavailable`	نعم
`error`	`string` `dataset_unavailable`	نعم
`origins`	`OriginT[]`	لا
`licenses`	`WordLicenseT[]`	لا
`description`	`string \| null`	لا
`dataset`	`string`	نعم
`title`	`string`	لا
`active`	`boolean`	نعم
`source`	`string`	نعم
`dataset_version`	`string \| null`	نعم
`license`	`string`	نعم
`license_url`	`string`	نعم
`attribution`	`string`	نعم
`attribution_url`	`string \| null`	نعم
`notice`	`string`	نعم
`license_text`	`string`	نعم

PublicSearchDatasetV1T

الاسم	النوع	مطلوب	الوصف

PublicSearchDatasetsV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicSearchDatasetV1T[]`	نعم
`meta`	`object`	نعم

PublicSemanticMatchV1T

A matching existing sense, with cosine similarity (not a confidence probability).

الاسم	النوع	مطلوب	الوصف
`word`	`PublicSearchWordV1T`	نعم
`meaning`	`object`	نعم
`score`	`number`	نعم	Cosine similarity from -1 to 1; no calibrated no-answer threshold.

PublicSemanticSearchV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`PublicSemanticMatchV1T[]`	نعم
`meta`	`object`	نعم

PublicSemanticStatusV1ResT

الاسم	النوع	مطلوب	الوصف
`data`	`object`	نعم