# API v2 kreditter, fakturering og brug > Læs din delte GenderAPI-saldo, og forstå v2-kreditomkostninger, fakturerbare ukendte, tilbagebetalinger, negative saldi og IP-prøvenulstillingstider. Canonical HTML: https://www.genderapi.io/da/docs/v2/credits-and-usage Last reviewed: 2026-09-25 ## Credits, ukendte resultater og brug En gennemført forudsigelse med gender: null koster kreditter i henhold til den valgte tilstand. Telefonvalidering koster 1 kredit, selv når valid: false. Indtastningsvalideringsfejl før fakturering koster ingen kreditter. Mislykkede forudsigelser koster ingen kreditter efter en bekræftet refusion. En positiv startsaldo er nok til at starte en enkelt anmodning eller en batch. Det endelige fradrag kan gøre saldoen negativ. For eksempel, ved at starte med 1 kredit og bruge en AI-operation, der koster 2 kreditter, efterlader en saldo på -1. En nul eller negativ saldo forhindrer nye operationer, der koster kreditter. Refusion er fortsat mulig. Tjek meta.usage.billing_status. Værdien not_charged betyder, at ingen kreditter blev fratrukket og charged_credits: 0. Værdien confirmed betyder, at den endelige pris er kendt. Værdien unconfirmed betyder, at charged_credits er null, og faktureringsresultatet skal kontrolleres. remaining_credits kan være negativ, eller null, hvis den ikke er tilgængelig. Denne saldo registreres, når handlingen er fuldført, og kan ændre sig, når andre anmodninger kører samtidigt. GET /brug er gratis. Det returnerer remaining_credits og expires_at. Til IP-prøveversionen returnerer den også resets_at, limit og period_seconds. Prøvegrænsen er 10 point og perioden er 86400 sekunder. Disse felter, der kun kan prøves, er null for API-nøglekonti. resets_at er prøvens nulstillingstid, ikke abonnementets udløbsdato. V1 og v2 bruger den samme kreditsaldo. Samtidige balanceopdateringer fra v1 og v2 kan være i konflikt. Gå ikke ud fra, at fakturering er garanteret præcis én gang på tværs af begge versioner. ```json { "data": { "remaining_credits": 9, "expires_at": "2026-09-26T12:00:00.000Z", "resets_at": "2026-09-26T12:00:00.000Z", "limit": 10, "period_seconds": 86400 }, "meta": { "request_id": "11111111-1111-4111-8111-111111111111", "duration_ms": 12, "access": { "mode": "ip_trial", "reason": "api_key_missing" }, "usage": { "charged_credits": 0, "remaining_credits": 9, "billing_status": "not_charged", "resets_at": "2026-09-26T12:00:00.000Z", "limit": 10, "period_seconds": 86400 } } } ``` ## Tjek den aktuelle saldo GET /api/v2/usage er gratis og tager Bearer-godkendelse uden forespørgselsparametre. Udeladelse af en nøgle læser den aktuelle IP prøvegodtgørelse. Kør disse eksempler på din server. Indstil GENDERAPI_API_KEY i procesmiljøet til din eksisterende API nøgle. Bekræft, at meta.access.mode er api_key: en ikke-genkendt nøgle kan falde tilbage til IP-prøveversionen. Denne saldoaflæsning koster ingen kreditter. Det tæller stadig med for anmodningssatsgrænser. HTTP 4xx og 5xx JSON-svar bevarer fejlteksten og returnerer en udgangsstatus, der ikke er nul. Tjek code, action og meta.usage.billing_status, før du prøver igen. **cURL** cURL 7.76+ i en POSIX-skal. Kør i din terminal. ```bash curl --silent --show-error --fail-with-body --max-time 30 \ --request GET 'https://api.genderapi.io/api/v2/usage' \ --header "Authorization: Bearer ${GENDERAPI_API_KEY:?Set GENDERAPI_API_KEY}" ``` **JavaScript / Node.js** Node.js 22+; indbygget apport. Gem som example.mjs og kør node example.mjs. ```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 response = await fetch("https://api.genderapi.io/api/v2/usage", { method: "GET", headers: { Authorization: `Bearer ${apiKey}`, }, 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+; standard bibliotek. Gem som example.py og kør python3 example.py. ```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") 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/usage", method="GET", headers={ "Authorization": "Bearer " + api_key, }, ) 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+ med cURL-udvidelsen. Gem som example.php og kør php example.php. ```php 'GET', CURLOPT_RETURNTRANSFER => true, CURLOPT_FOLLOWLOCATION => false, CURLOPT_TIMEOUT => 30, CURLOPT_HTTPHEADER => [ 'Authorization: Bearer ' . $apiKey, ], ]); $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 klient. Gem som GenderApiExample.java og kør java GenderApiExample.java. ```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"); 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/usage")) .timeout(Duration.ofSeconds(30)) .header("Authorization", "Bearer " + apiKey) .GET() .build(); HttpResponse 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** .NET 8+ konsolapplikation. Brug som Program.cs i et konsolprojekt, og kør derefter dotnet run. ```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.Get, "https://api.genderapi.io/api/v2/usage"); request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey); 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+; standard bibliotek. Gem som main.go og kør go run main.go. ```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") request, err := http.NewRequest("GET", "https://api.genderapi.io/api/v2/usage", nil) if err != nil { return err } request.Header.Set("Authorization", "Bearer " + apiKey) 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) } } ``` - [AI-tariffer efter tilstand](https://www.genderapi.io/da/docs/v2/ai-options) - [Ubekræftet fakturering og genforsøg](https://www.genderapi.io/da/docs/v2/errors-and-retries)