# Geschlecht aus chinesischen Namen bestimmen

> Testen Sie chinesische Namen mit GenderAPI.io V2. Erfahren Sie, wie kurze Bestandteile, die Aufteilung vollständiger Namen, ursprüngliche Schriftzeichen und der Kontext CN Ergebnisse aus Datensatz und KI beeinflussen.

Canonical HTML: https://www.genderapi.io/de/determine-gender-from-chinese-names

Last reviewed: 2026-09-28

## Unicode-Eingabe und Aufteilung vollständiger Namen unterscheiden

Sie können einen chinesischen Namen als Unicode-Text senden, ohne ihn in lateinische Schrift umzuwandeln. Die aktuelle Suche prüft normalisierte Bestandteile; einen ohne Leerzeichen geschriebenen vollständigen chinesischen Namen teilt sie nicht automatisch in Familienname und Vorname auf. 王静怡 ist daher ein einziger Kandidat und keine garantierte Suche nach 静怡.

Für die gängigen chinesischen Schriftzeichen in diesen Beispielen überspringt der aktuelle Kandidatenfilter des Datensatzes Bestandteile mit einem oder zwei Zeichen. Ein kurzer Vorname kann eine gültige Eingabe sein und trotzdem keinen Kandidaten ergeben. Der gewöhnliche KI-Fallback kann den ursprünglich gesendeten Wert weiterhin auswerten; eine Anfrage nur mit dem Datensatz behält das unbekannte Ergebnis bei.

Die Unicode-Normalisierung NFKC bietet keine allgemeine Umwandlung zwischen vereinfachtem und traditionellem Chinesisch und ordnet eine lateinische Schreibweise nicht einem einzigen ursprünglichen chinesischen Namen zu. Bewahren Sie die gesendete Schreibweise auf und prüfen Sie den zurückgegebenen Treffer. Die Position des Familiennamens, die Schrift oder die Romanisierung genügen nicht, um auf das Geschlecht oder das Land einer Person zu schließen.

| Beispielhafte Eingabe | Was sie zeigt | Was Sie prüfen sollten |
| --- | --- | --- |
| `王静怡` | Vollständiger Name ohne Leerzeichen | Ein Kandidat im Datensatz. Der aktuelle Parser trennt den Familiennamen nicht ab. |
| `静怡` | Vorname mit zwei Zeichen | Wird vom Längenfilter für Kandidaten übersprungen; der KI-Fallback kann den ursprünglichen Wert auswerten. |
| `王 静怡` | Getrennte kurze Bestandteile | Ein zusätzliches Leerzeichen umgeht den Längenfilter nicht. Beide Bestandteile dieses Beispiels sind für die Suche im Datensatz zu kurz. |
| `Wang Jingyi` | Eingabe in lateinischer Schrift | Wird als eigener Wert behandelt und in eigene Bestandteile zerlegt. Es ist nicht garantiert, dass er den ursprünglichen Schriftzeichen oder demselben Eintrag zugeordnet wird. |

## Länderkontext CN bewusst wählen

Die Demo sendet country: CN (China). Die API wählt dieses Land nicht anhand der Schrift aus, in der der Name geschrieben ist. Verwenden Sie in Ihrer Integration einen bekannten und passenden Länderkontext oder lassen Sie country weg. Machen Sie dieses Beispiel nicht zum Standardwert für alle Datensätze.

Für jeden Kandidaten wählt die Suche den länderspezifischen Eintrag, sofern vorhanden, und prüft andernfalls den globalen Eintrag. Anschließend wählt sie den verfügbaren Kandidaten mit der größten gespeicherten Gesamthäufigkeit. Den tatsächlichen Umfang des Treffers sehen Sie in data.match.scope und data.match.country. Ein länderspezifischer Eintrag mit gleichen Häufigkeiten wird nicht automatisch durch das globale Ergebnis ersetzt; ist der Fallback aktiviert, kann stattdessen KI eingesetzt werden.

data.input.country beschreibt den in der Anfrage gesendeten Kontext. data.country und data.country_source beschreiben die zurückgegebene Länderzuordnung und ihre Herkunft. Das sind unterschiedliche Felder; sie belegen weder Staatsangehörigkeit noch ethnische Herkunft noch Wohnort.

- [Länderkontext und Treffer](https://www.genderapi.io/de/docs/v2/gender-from-name#country-evidence-workflow)

## V2-Namensanfrage aus Ihrer Anwendung senden

Setzen Sie GENDERAPI_API_KEY auf Ihren vorhandenen Schlüssel und führen Sie das Beispiel auf Ihrem Server aus. Die Anfrage aktiviert ausdrücklich den gewöhnlichen KI-Fallback. Sie zeigt das Anfrageformat, keine gemessene Genauigkeit und keine bestätigte Abdeckung. Für eine Vorhersage nur mit dem Datensatz verwenden Sie options.ai_mode: off.

Führen Sie diese Beispiele auf Ihrem Server aus. Setzen Sie GENDERAPI_API_KEY in der Prozessumgebung auf Ihren vorhandenen API-Schlüssel. Prüfen Sie, ob meta.access.mode den Wert api_key hat: Ein nicht erkannter Schlüssel kann in den IP-Testzugang wechseln.

Jede Vorhersageanfrage ist ein neuer kostenpflichtiger Vorgang, auch bei Wiederholungen. Diese Beispiele wiederholen Anfragen nicht automatisch. Prüfen Sie den Abrechnungsstatus, bevor Sie eine weitere Anfrage senden.

Bei HTTP-4xx- und -5xx-Antworten im JSON-Format bleibt der Fehlerinhalt erhalten, und das Beispiel endet mit einem Exit-Status ungleich null. Prüfen Sie code, action und meta.usage.billing_status, bevor Sie die Anfrage wiederholen.

**cURL**

cURL 7.76+ in einer POSIX-Shell. Im Terminal ausführen.

```bash
curl --silent --show-error --fail-with-body --max-time 30 \
  --request POST 'https://api.genderapi.io/api/v2/gender' \
  --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" \
  --header 'Content-Type: application/json' \
  --data '{
  "type": "name",
  "value": "王静怡",
  "country": "CN",
  "options": {
    "ai_mode": "fallback"
  }
}'
```

**JavaScript / Node.js**

Node.js 22+; integriertes fetch. Als example.mjs speichern und node example.mjs ausführen.

```javascript
// Server-side Node.js. Save as example.mjs.
const apiKey = process.env.GENDERAPI_API_KEY;
if (!apiKey) throw new Error("Set GENDERAPI_API_KEY");
const body = {
  "type": "name",
  "value": "王静怡",
  "country": "CN",
  "options": {
    "ai_mode": "fallback"
  }
};

const response = await fetch("https://api.genderapi.io/api/v2/gender", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify(body),
  signal: AbortSignal.timeout(30_000),
  redirect: "error",
});
const raw = await response.text();
if (!(response.headers.get("content-type") ?? "").includes("json")) {
  throw new Error(`HTTP ${response.status}: expected JSON; request ID ${response.headers.get("x-request-id")}`);
}
const result = JSON.parse(raw); // Also accepts application/problem+json.
if (!response.ok) {
  console.error(`HTTP ${response.status}`, result);
  process.exitCode = 1; // A retry is a new operation; inspect billing first.
} else {
  console.log(JSON.stringify(result, null, 2));
  // For batches, inspect every item: HTTP 200 may contain item errors.
}
```

**Python**

Python 3.10+; Standardbibliothek. Als example.py speichern und python3 example.py ausführen.

```python
import json
import os
import sys
import urllib.error
import urllib.request

api_key = os.environ.get("GENDERAPI_API_KEY")
if not api_key:
    raise RuntimeError("Set GENDERAPI_API_KEY")
body = json.loads("{\"type\":\"name\",\"value\":\"王静怡\",\"country\":\"CN\",\"options\":{\"ai_mode\":\"fallback\"}}")

class NoRedirect(urllib.request.HTTPRedirectHandler):
    def redirect_request(self, req, fp, code, msg, headers, newurl):
        return None

request = urllib.request.Request(
    "https://api.genderapi.io/api/v2/gender",
    method="POST",
    data=json.dumps(body).encode("utf-8"),
    headers={
        "Authorization": "Bearer " + api_key,
        "Content-Type": "application/json",
    },
)
opener = urllib.request.build_opener(NoRedirect())
try:
    response = opener.open(request, timeout=30)
except urllib.error.HTTPError as error:
    response = error  # Keep the Problem Details body on non-2xx responses.
with response:
    status = response.status
    raw = response.read().decode("utf-8")
    if "json" not in response.headers.get("Content-Type", ""):
        raise RuntimeError(f"HTTP {status}: expected a JSON response")
    result = json.loads(raw)
print(json.dumps(result, indent=2), file=sys.stderr if status >= 300 else sys.stdout)
if not 200 <= status < 300:
    sys.exit(1)  # Inspect code, action and billing before retrying.
# For batches, inspect every item even when HTTP status is 200.
```

**PHP**

PHP 8+ mit der cURL-Erweiterung. Als example.php speichern und php example.php ausführen.

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"type":"name","value":"王静怡","country":"CN","options":{"ai_mode":"fallback"}}', true, 512, JSON_THROW_ON_ERROR);

$ch = curl_init('https://api.genderapi.io/api/v2/gender');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => 'POST',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FOLLOWLOCATION => false,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTPHEADER => [
        'Authorization: Bearer ' . $apiKey,
        'Content-Type: application/json',
    ],
    CURLOPT_POSTFIELDS => json_encode($body, JSON_THROW_ON_ERROR),
]);
$raw = curl_exec($ch);
if ($raw === false) {
    throw new RuntimeException(curl_error($ch));
}
$status = curl_getinfo($ch, CURLINFO_HTTP_CODE);
$contentType = curl_getinfo($ch, CURLINFO_CONTENT_TYPE) ?: '';
curl_close($ch);
if (strpos($contentType, 'json') === false) {
    throw new RuntimeException("HTTP $status: expected a JSON response");
}
$result = json_decode($raw, true, 512, JSON_THROW_ON_ERROR);
$output = json_encode($result, JSON_PRETTY_PRINT | JSON_THROW_ON_ERROR) . PHP_EOL;
if ($status < 200 || $status >= 300) {
    fwrite(STDERR, $output); // Preserve the Problem Details body.
    exit(1);
}
echo $output;
// For batches, inspect every item; HTTP 200 can contain item errors.
```

**Java**

Java 17+; Standard-HTTP-Client. Als GenderApiExample.java speichern und java GenderApiExample.java ausführen.

```java
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.charset.StandardCharsets;
import java.time.Duration;

public class GenderApiExample {
    private static String requiredEnv(String name) {
        String value = System.getenv(name);
        if (value == null || value.isBlank()) throw new IllegalStateException("Set " + name);
        return value;
    }

    public static void main(String[] args) throws Exception {
        String apiKey = requiredEnv("GENDERAPI_API_KEY");
        String body = "{\"type\":\"name\",\"value\":\"王静怡\",\"country\":\"CN\",\"options\":{\"ai_mode\":\"fallback\"}}";
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10))
            .followRedirects(HttpClient.Redirect.NEVER)
            .build();
        HttpRequest request = HttpRequest.newBuilder(URI.create("https://api.genderapi.io/api/v2/gender"))
            .timeout(Duration.ofSeconds(30))
            .header("Authorization", "Bearer " + apiKey)
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body, StandardCharsets.UTF_8))
            .build();
        HttpResponse<String> response = client.send(request,
            HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
        if (!response.headers().firstValue("content-type").orElse("").contains("json")) {
            throw new IllegalStateException("HTTP " + response.statusCode() + ": expected JSON");
        }
        // JSON text; parse with your application's JSON library when integrating.
        if (response.statusCode() < 200 || response.statusCode() >= 300) {
            System.err.println(response.body()); // Includes Problem Details.
            System.exit(1);
        }
        System.out.println(response.body());
        // For batches, inspect each item's data or error, including on HTTP 200.
    }
}
```

**C# / .NET**

Konsolenanwendung mit .NET 8+. Als Program.cs in einem Konsolenprojekt verwenden und dann dotnet run ausführen.

```csharp
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text;
using System.Text.Json;

string RequiredEnv(string name) =>
    !string.IsNullOrWhiteSpace(Environment.GetEnvironmentVariable(name))
        ? Environment.GetEnvironmentVariable(name)!
        : throw new InvalidOperationException($"Set {name}");

var apiKey = RequiredEnv("GENDERAPI_API_KEY");
using var handler = new HttpClientHandler { AllowAutoRedirect = false };
using var client = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(30) };
using var request = new HttpRequestMessage(HttpMethod.Post, "https://api.genderapi.io/api/v2/gender");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"type\":\"name\",\"value\":\"王静怡\",\"country\":\"CN\",\"options\":{\"ai_mode\":\"fallback\"}}", Encoding.UTF8, "application/json");

using var response = await client.SendAsync(request);
var raw = await response.Content.ReadAsStringAsync();
if (!(response.Content.Headers.ContentType?.MediaType?.Contains("json") ?? false))
    throw new InvalidOperationException($"HTTP {(int)response.StatusCode}: expected JSON");
using var result = JsonDocument.Parse(raw);
if (!response.IsSuccessStatusCode)
{
    Console.Error.WriteLine(result.RootElement); // Preserve Problem Details.
    Environment.ExitCode = 1;
}
else
{
    Console.WriteLine(result.RootElement);
    // For batches, inspect every item even on HTTP 200.
}
```

**Go**

Go 1.22+; Standardbibliothek. Als main.go speichern und go run main.go ausführen.

```go
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "os"
    "strings"
    "time"
)

func requiredEnv(name string) string {
    value := os.Getenv(name)
    if value == "" { panic("Set " + name) }
    return value
}

func run() error {
    apiKey := requiredEnv("GENDERAPI_API_KEY")
    body := "{\"type\":\"name\",\"value\":\"王静怡\",\"country\":\"CN\",\"options\":{\"ai_mode\":\"fallback\"}}"
    request, err := http.NewRequest("POST", "https://api.genderapi.io/api/v2/gender", strings.NewReader(body))
    if err != nil { return err }
    request.Header.Set("Authorization", "Bearer " + apiKey)
    request.Header.Set("Content-Type", "application/json")
    client := &http.Client{
        Timeout: 30 * time.Second,
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            return http.ErrUseLastResponse
        },
    }
    response, err := client.Do(request)
    if err != nil { return err }
    defer response.Body.Close()
    raw, err := io.ReadAll(response.Body)
    if err != nil { return err }
    if !strings.Contains(response.Header.Get("Content-Type"), "json") || !json.Valid(raw) {
        return fmt.Errorf("HTTP %d: expected a JSON response", response.StatusCode)
    }
    if response.StatusCode < 200 || response.StatusCode >= 300 {
        return fmt.Errorf("HTTP %d: %s", response.StatusCode, raw)
    }
    fmt.Println(string(raw))
    // For batches, inspect every item even on HTTP 200.
    return nil
}

func main() {
    if err := run(); err != nil {
        fmt.Fprintln(os.Stderr, err) // Keep Problem Details for error handling.
        os.Exit(1)
    }
}
```

- [Parameter für Namensanfragen](https://www.genderapi.io/de/docs/v2/gender-from-name)
- [API-Schlüssel einrichten](https://www.genderapi.io/de/docs/v2/authentication)

## Ergebnis und Belege gemeinsam aufbewahren

Eine abgeleitete Zuordnung ist nicht das Geschlecht, das eine Person selbst angibt. Bewahren Sie die ursprüngliche Eingabe, die zurückgegebenen Belege und alle Angaben der Person selbst getrennt auf. Ein unbekanntes Ergebnis ist ein gültiges Ergebnis; es sollte in Ihrer Anwendung nicht zu einer geratenen Kategorie werden.

| Feld | Verwendung |
| --- | --- |
| `data.gender / data.result_status` | Verwenden Sie male oder female nur bei identified. Behalten Sie bei einem unbekannten Ergebnis den nativen JSON-Wert null bei. |
| `data.name / data.match` | Prüfen Sie den zurückgegebenen Namen und den ausgewählten Kandidaten. Ein Treffer über einen Teilstring belegt nicht, dass die Eingabe zu einer Person mit diesem Vornamen gehört. |
| `data.confidence / data.confidence_kind` | Die Konfidenz liegt auf einer Skala von 0–1 oder ist null. observed_frequency beruht auf gespeicherten Häufigkeiten; model_reported ist ein KI-Wert. Bewerten Sie Schwellenwerte für jede Art getrennt. |
| `data.source / data.sample_count` | Unterscheiden Sie dataset, ai und none. KI-Ergebnisse haben keine gespeicherte Stichprobengröße. Eine Stichprobengröße ist kein gemessener Genauigkeitswert. |
| `meta.access.mode` | Prüfen Sie bei einer Kontointegration, ob api_key gemeldet wird. Fehlende oder nicht erkannte Schlüssel können stattdessen den gemeinsamen IP-Testzugang nutzen. |
| `meta.usage` | Lesen Sie charged_credits und billing_status. Ein erfolgreiches unbekanntes Ergebnis ist kostenpflichtig. Eine verlorene Antwort belegt nicht, dass die Anfrage kostenlos war. |

- [Antwortfelder und unbekannte Ergebnisse](https://www.genderapi.io/de/docs/v2/responses)
- [Genauigkeit und Konfidenz erklärt](https://www.genderapi.io/de/accuracy-methodology)
- [Datenquellen und das datierte Datenbankprofil](https://www.genderapi.io/de/data-provenance)

## Festlegen, wann KI eingesetzt wird

forceToGenderize ist für Namen, E-Mail-Adressen und Benutzernamen optional. Ist es aktiviert, lassen Sie ai_mode weg oder verwenden Sie fallback; off und always sind damit unvereinbar und liefern 422. Ein positives Anfangsguthaben genügt, um eine Anfrage zu starten, auch wenn die endgültige Abbuchung das Guthaben unter null senkt.

Der Spitznamenmodus kann ein Geschlecht zusammen mit name: null zurückgeben. Er kann auch ein unbekanntes Ergebnis liefern. Weder der gewöhnliche KI-Fallback noch die Spitznamen-Auswertung garantieren eine richtige Antwort oder einen Wert ungleich null.

| Anfrageoption | Verhalten | Credits für eine erfolgreiche Abfrage |
| --- | --- | --- |
| options.ai_mode: off | Nur den Datensatz verwenden. | 1, auch bei einem unbekannten Ergebnis |
| options.ai_mode: fallback | Zuerst den Datensatz prüfen, dann gewöhnliche KI, wenn kein Geschlecht zurückgegeben wird. Das ist der Standard für Einzelanfragen. | Insgesamt 1, einschließlich KI-Fallback |
| options.ai_mode: always | Direkt KI verwenden. | 2 |
| forceToGenderize: true | Zuerst den Datensatz prüfen, dann KI einen persönlichen Spitznamen oder Alias auswerten lassen, auch ohne echten Vornamen. | 1 für ein im Datensatz aufgelöstes Ergebnis; insgesamt 2, wenn KI eingesetzt wird |

- [KI-Optionen und Spitznamen-Auswertung](https://www.genderapi.io/de/docs/v2/ai-options)
- [Credits und Nutzung](https://www.genderapi.io/de/docs/v2/credits-and-usage)

## Eine Namensliste verarbeiten, ohne den Kontext zu verlieren

Senden Sie bis zu 50 Einträge mit API-Schlüssel oder 10 im IP-Testzugang über POST /api/v2/gender/batch. Geben Sie den Einträgen eindeutige IDs und bewahren Sie den ursprünglichen Wert jeder Zeile auf. Jeder Eintrag kann eigene Länder- und KI-Optionen haben; lassen Sie das Land weg, wenn es unbekannt ist.

Anders als Einzelanfragen, die standardmäßig den Fallback verwenden, nutzen Batch-Einträge standardmäßig nur den Datensatz. Setzen Sie options.ai_mode: fallback in jedem Eintrag, der KI benötigt. Prüfen Sie jedes Ergebnis, auch nach HTTP 200, behalten Sie unbekannte Ergebnisse bei und prüfen Sie Fehler sowie die Abrechnung, bevor Sie erneut senden. Jeder erfolgreiche gewöhnliche Eintrag kostet 1 Credit; eine HTTP-Anfrage mit einem Batch ist nicht ein Credit pro Vorhersage.

- [Batch-Beispiele und Teilfehler](https://www.genderapi.io/de/docs/v2/batch#batch-application-workflow)
- [Unbekannte Ergebnisse in der Anwendung behandeln](https://www.genderapi.io/de/docs/v2/responses#application-decisions)

## Wissen, was Sie senden

Die Live-Demo sendet den eingegebenen Wert erst dann an GenderAPI.io, wenn Sie ihn absenden. Wird KI eingesetzt, gehen der übermittelte type, der value und der Länderkontext an den konfigurierten Inferenzdienst. Für eine Vorhersage nur mit dem Datensatz verwenden Sie in Ihrer Integration options.ai_mode: off ohne forceToGenderize.

Die Datenschutzerklärung, der Auftragsverarbeitungsvertrag und das Verzeichnis der Unterauftragsverarbeiter beschreiben die veröffentlichten Verarbeitungsbedingungen. Ein Ergebnis ist eine abgeleitete Zuordnung; Angaben der Person selbst haben Vorrang. Nutzen Sie es nicht als Grundlage für folgenreiche Entscheidungen über eine Person.

- [Datenschutzerklärung](https://www.genderapi.io/de/privacy-policy)
- [Auftragsverarbeitungsvertrag](https://www.genderapi.io/de/data-processing-agreement)
- [Verzeichnis der Unterauftragsverarbeiter](https://www.genderapi.io/de/subprocessors)

## Warum kann ein chinesischer Vorname mit zwei Zeichen nur mit dem Datensatz unbekannt bleiben?

Der aktuelle Kandidatenfilter überspringt Bestandteile, deren JavaScript-Zeichenkettenlänge höchstens zwei beträgt. Für die hier gezeigten chinesischen Schriftzeichen ist ein Vorname mit zwei Zeichen eine gültige Eingabe, wird aber kein Kandidat im Datensatz. Der KI-Fallback kann den ursprünglichen Wert auswerten.

## Trennt V2 den chinesischen Familiennamen automatisch vom Vornamen?

Die Suche im Datensatz teilt einen ohne Leerzeichen geschriebenen vollständigen chinesischen Namen nicht auf. KI kann einen Vornamen aus dem vollständigen Wert ableiten, doch keiner der beiden Wege garantiert, dass der beabsichtigte Vorname ausgewählt wird. Prüfen Sie source und match in der Antwort.

## Wurde für diese Namensgruppe eine unabhängige Genauigkeitsbewertung veröffentlicht?

Diese Seite veröffentlicht keine solche Bewertung. Dass eine Eingabe angenommen wird, gespeicherte Häufigkeiten angezeigt werden oder ein Konfidenzwert zurückgegeben wird, ist keine unabhängige Messung der Genauigkeit. Die Methodik zeigt, welche Angaben verfügbar sind und welche Messungen noch nicht veröffentlicht wurden.

## Verbraucht ein Ergebnis ohne Vorhersage Credits?

Ein erfolgreiches unbekanntes Ergebnis ist kostenpflichtig. Der gewöhnliche Modus mit dem Datensatz oder mit Fallback kostet insgesamt 1 Credit. Mit forceToGenderize kostet die Anfrage 1 Credit, wenn der Datensatz sie auflöst, oder insgesamt 2, wenn KI eingesetzt wird, auch bei einem unbekannten Ergebnis. Für Fehler gelten eigene Abrechnungsregeln; prüfen Sie meta.usage.