# Crédits, facturation et utilisation API v2 > Lisez votre solde GenderAPI partagé et comprenez les coûts de crédit v2, les inconnues facturables, les remboursements, les soldes négatifs et les temps de réinitialisation de l'essai IP. Canonical HTML: https://www.genderapi.io/fr/docs/v2/credits-and-usage Last reviewed: 2026-09-25 ## Crédits, résultats et utilisation inconnus Une prédiction terminée avec gender: null coûte des crédits selon le mode sélectionné. La validation téléphonique coûte 1 crédit même lorsque valid: false. Les erreurs de validation de saisie avant facturation ne coûtent aucun crédit. Les prédictions échouées ne coûtent aucun crédit après un remboursement confirmé. Un solde de départ positif suffit pour démarrer une seule demande ou un lot. La déduction finale peut rendre le solde négatif. Par exemple, commencer avec 1 crédit et utiliser une opération IA qui coûte 2 crédits laisse un solde de -1. Un solde nul ou négatif empêche de nouvelles opérations qui coûtent des crédits. Les remboursements restent possibles. Vérifiez meta.usage.billing_status. La valeur not_charged signifie qu'aucun crédit n'a été déduit et charged_credits: 0. La valeur confirmed signifie que le coût final est connu. La valeur unconfirmed signifie que charged_credits est null et que le résultat de la facturation doit être vérifié. remaining_credits peut être négatif, ou null s'il n'est pas disponible. Ce solde est enregistré une fois l'opération terminée et peut changer lorsque d'autres demandes sont exécutées simultanément. GET /utilisation est gratuit. Il renvoie remaining_credits et expires_at. Pour l'essai IP, il renvoie également resets_at, limit et period_seconds. La limite d'essai est de 10 crédits et la période est de 86 400 secondes. Ces champs d'essai uniquement sont null pour les comptes de clé API. resets_at correspond à l'heure de réinitialisation de l'essai, et non à la date d'expiration de l'abonnement. V1 et V2 utilisent le même solde de crédits. Des mises à jour simultanées du solde peuvent entrer en conflit. Ne supposez pas qu’une facturation exactement une fois est garantie entre les deux versions. ```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 } } } ``` ## Vérifier le solde actuel GET /api/v2/usage est gratuit et prend l'authentification Bearer, sans paramètres de requête. L'omission d'une clé lit l'allocation d'essai actuelle de IP. Exécutez ces exemples sur votre serveur. Définissez GENDERAPI_API_KEY dans l’environnement de processus sur votre clé API existante. Confirmez que meta.access.mode est api_key : une clé non reconnue peut revenir à l'essai IP. Cette lecture du solde ne coûte aucun crédit. Il est toujours pris en compte dans les limites de débit de demande. Les réponses HTTP 4xx et 5xx JSON préservent le corps de l'erreur et renvoient un état de sortie différent de zéro. Vérifiez code, action et meta.usage.billing_status avant de réessayer. **cURL** cURL 7.76+ dans un shell POSIX. Exécutez dans votre 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+ ; récupération intégrée. Enregistrez sous example.mjs et exécutez 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+ ; bibliothèque standard. Enregistrez sous example.py et exécutez 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+ avec l'extension cURL. Enregistrez sous example.php et exécutez 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+ ; client standard HTTP. Enregistrez sous GenderApiExample.java et exécutez 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** Application console .NET 8+. Utilisez comme Program.cs dans un projet de console, puis exécutez 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+ ; bibliothèque standard. Enregistrez sous main.go et exécutez 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) } } ``` - [Tarifs IA par mode](https://www.genderapi.io/fr/docs/v2/ai-options) - [Facturation et tentatives non confirmées](https://www.genderapi.io/fr/docs/v2/errors-and-retries)