# Autenticazione API v2 e prova gratuita

> Autentica GenderAPI v2 con la chiave API esistente. Scopri le intestazioni Bearer, le chiavi di query GET, l'accesso di prova IP e le richieste JSON.

Canonical HTML: https://www.genderapi.io/it/docs/v2/authentication

Last reviewed: 2026-09-25

## Autenticazione e prova gratuita

Invia Authorization: Bearer YOUR_API_KEY dal tuo server. Sostituisci YOUR_API_KEY con la chiave GenderAPI esistente. Entrambe le versioni condividono il tuo saldo; non è richiesto alcun abbonamento o chiave v2 separata.

Tutte le richieste POST richiedono Content-Type: application/json. Utilizza la chiave Bearer API esistente. Ogni richiesta viene elaborata in modo autonomo; le richieste ripetute utilizzano la fatturazione normale.

Solo GET /gender accetta anche il parametro di query chiave. Preferisci l'intestazione Autorizzazione per le integrazioni perché gli URL possono essere archiviati nella cronologia e nei log del browser. Non inserire chiavi private nel codice frontend.

Se una chiave API manca, ha un formato non valido o non viene riconosciuta, la richiesta utilizza la versione di prova IP condivisa con v1. Ciò non si applica alle chiavi riconosciute che sono disabilitate, scadute o limitate. Verificare la modalità di accesso in meta.access.mode: api_key, ip_trial o unauthenticated. Il motivo della prova è api_key_missing, api_key_invalid o api_key_not_found. Una chiave non valida può quindi ancora ricevere una risposta di prova riuscita. Verificare la modalità di accesso in produzione.

I crediti di prova vengono reimpostati dopo un periodo di 24 ore, non necessariamente a mezzanotte. Utilizzare /usage per leggere resets_at. Le persone dietro lo stesso pubblico IP condividono questa indennità.

- [Accedi al tuo account GenderAPI](https://app.genderapi.io/user/login)
- [Crea un account](https://app.genderapi.io/user/register)

## Configura la tua chiave API

Copia la tua chiave API dal tuo account GenderAPI. Sostituisci YOUR_API_KEY di seguito con quella chiave, quindi esegui l'esempio scelto nella stessa sessione del terminale. Questi comandi impostano una variabile di ambiente solo per quella sessione; il segnaposto pubblicato non è una chiave funzionante.

Per un'applicazione o una distribuzione, configurare GENDERAPI_API_KEY come segreto lato server. Gli esempi non caricano automaticamente un file .env. Tieni la chiave fuori dai bundle del browser, dal controllo del codice sorgente e dagli URL pubblici.

**terminale macOS/Linux**

```bash
export GENDERAPI_API_KEY='YOUR_API_KEY'
```

**Windows PowerShell**

```powershell
$env:GENDERAPI_API_KEY = 'YOUR_API_KEY'
```

## Verifica l'accesso senza spendere crediti

Chiama GET /usage con l'intestazione Bearer. Una chiave account valida produce meta.access.mode: api_key. Se il risultato dice ip_trial, controlla la chiave copiata prima di eseguire le previsioni. Questa richiesta è gratuita, anche per i conti senza credito residuo.

Esegui questi esempi sul tuo server. Impostare GENDERAPI_API_KEY nell'ambiente di processo sulla chiave API esistente. Conferma che meta.access.mode è api_key: una chiave non riconosciuta può ricadere nella versione di prova IP.

Questa lettura del saldo non costa crediti. Viene comunque conteggiato ai fini dei limiti di velocità delle richieste.

HTTP Le risposte 4xx e 5xx JSON preservano il corpo dell'errore e restituiscono uno stato di uscita diverso da zero. Controllare code, action e meta.usage.billing_status prima di riprovare.

**cURL**

cURL 7.76+ in una shell POSIX. Esegui nel tuo terminale.

```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+; recupero integrato. Salva come example.mjs ed esegui 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+; libreria standard. Salva come example.py ed esegui 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+ con estensione cURL. Salva come example.php ed esegui php example.php.

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}

$ch = curl_init('https://api.genderapi.io/api/v2/usage');
curl_setopt_array($ch, [
    CURLOPT_CUSTOMREQUEST => '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 HTTP standard. Salva come GenderApiExample.java ed esegui 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<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**

Applicazione console .NET 8+. Utilizzare come Program.cs in un progetto console, quindi eseguire 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+; libreria standard. Salva come main.go ed esegui 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)
    }
}
```

## Passi successivi

- [Fai una previsione del nome](https://www.genderapi.io/it/docs/v2/gender-from-name)
- [Leggi il saldo del tuo credito](https://www.genderapi.io/it/docs/v2/credits-and-usage)
- [Riprovare le richieste in modo sicuro](https://www.genderapi.io/it/docs/v2/errors-and-retries#retries)