Vokabelliste erzeugen

API-Version 2026-10-affable-towhee

post https://api.getlingara.com/v1/vocab/stream

Streamt eine Liste von Wörtern auf dem angeforderten Niveau. Der Stream sendet started mit den Details der Liste, ein item-Ereignis pro Wort und dann done. Bis die Liste fertig ist, sendet er nur Keepalive-Kommentare.

Scopes vocab:generate

Parameter

Lingara-Versionheaderstringoptional: Die API-Version, unter der diese Anfrage beantwortet wird. Ohne sie erhält ein Zugriffstoken die Version, an die sein Client gebunden ist, und eine Anfrage ohne Token die aktuelle Version. Die Version in Entwicklung ist nur erreichbar, indem man sie hier nennt. Eine unbekannte Version wird mit 400 und dem Code api_version_unknown beantwortet. GET /v1/versions listet die Versionen auf.

Anfragetext `application/json`

levelintegererforderlich
source_langstringerforderlich
target_langstringerforderlich
countinteger | nulloptional

Antworten

200 Die Liste, ein Wort pro Ereignis

Stream-Ereignisse `text/event-stream`

Sendet alle 15 Sekunden einen Keepalive-Kommentar.

started VocabStarted

metaVocabMetaerforderlich

levelintegererforderlich
source_langstringerforderlich
target_langstringerforderlich
frameworkstringerforderlich
countintegererforderlich
ai_generatedbooleanerforderlich

item VocabItem

wordstringerforderlich

pronunciationstring | nulloptional

readingstring | nulloptional

translationstringerforderlich

exampleVocabExample | nulloptional

sentencestringerforderlich
translationstringerforderlich

image_urlstring | nulloptional

done Done Beendet den Stream

error StreamError Beendet den Stream

Kommt innerhalb der 200-Antwort an. Die Statuszeile wurde bereits gesendet, daher wird ein Fehler nach dem Öffnen des Streams als dieses Ereignis gemeldet.

codestringerforderlich
messagestringerforderlich
plan_idstring | nulloptional

Fehler

402application/json: Der Aufruf eines nutzungsbasiert abgerechneten Clients wurde abgelehnt, bevor er etwas verbraucht hat. spend_cap_reached: Der Client oder sein Konto hat sein monatliches Ausgabenlimit erreicht; erhöhe das Limit auf der Seite Integrationen. metered_billing_inactive: Die Nutzungsabrechnung ist für dieses Konto nicht aktiv; richte sie ein oder aktualisiere die Zahlungsmethode auf der Seite Integrationen.
410application/json: Die API-Version, unter der diese Anfrage beantwortet wird, wurde eingestellt. Sende eine unterstützte Version in Lingara-Version oder binde den Client an eine andere Version.
4XXapplication/json: Die Anfrage wurde abgelehnt. code nennt den Grund, und error beschreibt ihn in Worten.
503application/json · text/plain: Der Dienst ist vorübergehend nicht verfügbar; versuche es nach der in Retry-After angegebenen Anzahl Sekunden erneut. Während Wartungsarbeiten ist der Body reiner Text statt des Fehlerumschlags.
5XXapplication/json: Die Anfrage wurde abgelehnt. code nennt den Grund, und error beschreibt ihn in Worten.

codestringerforderlich: Warum die Anfrage abgelehnt wurde, als stabiler Code, nach dem du verzweigen kannst: zum Beispiel insufficient_scope (403), rate_limited (429) und, bei einem nutzungsbasiert abgerechneten Client, spend_cap_reached (402) und metered_billing_inactive (402).
errorstringerforderlich

Beispiel

curlTypeScriptRustGoJavaKotlinRubyPHP

curl

curl -N -X POST "https://api.getlingara.com/v1/vocab/stream" \
  -H "Authorization: Bearer $LINGARA_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"level":2,"source_lang":"en","target_lang":"zh","count":8}'

TypeScript

const stream = client.generateVocabulary({ level: 2, source_lang: "en", target_lang: "zh", count: 8 });
for await (const ev of stream) {
  if (ev.event === "item") console.log(ev.data.word, ev.data.translation);
}

Rust

use lingara::models::{GenerateVocabularyEvent, VocabRequest};
use std::num::NonZeroU8;

let request = VocabRequest { level: 2, source_lang: "en".into(), target_lang: "zh".into(), count: NonZeroU8::new(8) };
let mut stream = client.generate_vocabulary(&request).await?;
while let Some(event) = stream.next().await {
    if let GenerateVocabularyEvent::Item(item) = event? {
        println!("{} {}", item.word, item.translation);
    }
}

count := uint8(8)
s, err := client.GenerateVocabulary(ctx, lingara.VocabRequest{Level: 2, SourceLang: "en", TargetLang: "zh", Count: &count})
if err != nil {
	return err
}
defer s.Close()
for ev, err := range s.Events() {
	if err != nil {
		return err
	}
	if item, ok := ev.(lingara.GenerateVocabularyEventItem); ok {
		fmt.Println(item.Data.Word, item.Data.Translation)
	}
}

Java

import com.getlingara.client.model.GenerateVocabularyEvent;
import com.getlingara.client.model.VocabRequest;

VocabRequest request = new VocabRequest().level(2).sourceLang("en").targetLang("zh").count(8);
try (EventStream<GenerateVocabularyEvent> stream = client.generateVocabulary(request)) {
  for (GenerateVocabularyEvent event : stream) {
    if (event instanceof GenerateVocabularyEvent.Item item) {
      System.out.println(item.data().getWord() + " " + item.data().getTranslation());
    }
  }
}

Kotlin

import com.getlingara.kotlin.LingaraClient
import com.getlingara.kotlin.model.GenerateVocabularyEvent
import com.getlingara.kotlin.model.VocabRequest

val request = VocabRequest(level = 2, sourceLang = "en", targetLang = "zh", count = 8)
// The request is sent here; collect the stream once, inside use {}.
client.generateVocabulary(request).use { stream ->
    stream.collect { event ->
        when (event) {
            is GenerateVocabularyEvent.Item -> println("${event.data.word} ${event.data.translation}")
            is GenerateVocabularyEvent.Started -> Unit
        }
    }
}

Ruby

client.generate_vocabulary(level: 2, source_lang: "en", target_lang: "zh", count: 8) do |event|
  case event
  in Lingara::GenerateVocabularyEventItem => item then puts "#{item.data.word}: #{item.data.translation}"
  else nil
  end
end

PHP

use Lingara\Model\VocabRequest;
use Lingara\Stream\GenerateVocabularyEvent;

$request = new VocabRequest(['level' => 2, 'source_lang' => 'en', 'target_lang' => 'zh', 'count' => 8]);
foreach ($client->generateVocabulary($request) as $event) {
    if ($event instanceof GenerateVocabularyEvent\Item) {
        echo $event->data->getWord(), ': ', $event->data->getTranslation(), "\n";
    }
}

Lieber eine Bibliothek? Siehe den Bereich Bibliotheken.

Beispiel-Stream

event: started
data: {"meta":{"level":2,"source_lang":"en","target_lang":"zh","framework":"HSK","count":2,"ai_generated":true}}

event: item
data: {"word":"你好","pronunciation":"nǐ hǎo","translation":"hello","example":{"sentence":"你好，我叫小明。","translation":"Hello, my name is Xiaoming."}}

event: item
data: {"word":"谢谢","pronunciation":"xiè xie","translation":"thank you"}

event: done
data: {}

Weichen eine Übersetzung und die englische Referenz voneinander ab, ist die englische Referenz maßgeblich.