# Sukupuoli sähköpostiosoitteesta API v2

> Käytä GenderAPI v2:ta sukupuolen päättelemiseen sähköpostin nimisignaalista. Sisältää pyyntö- ja vastausesimerkkejä, validoinnin, tuntemattomat tulokset ja tekoälyvaihtoehdot.

Canonical HTML: https://www.genderapi.io/fi/docs/v2/gender-from-email

Last reviewed: 2026-09-25

## Ennen pyynnön lähettämistä

Lähetä JSON numeroon POST https://api.genderapi.io/api/v2/gender. Käytä olemassa olevaa API-avainta malleissa Authorization: Bearer YOUR_API_KEY ja Content-Type: application/json. Jokainen pyyntö käsitellään itsenäisesti.

Valitse kieli koodiesimerkistä. Aseta GENDERAPI_API_KEY prosessiympäristöön ennen sen suorittamista. Puuttuvat tai tunnistamattomat avaimet voivat käyttää jaettua IP-kokeilua, joten varmista, että meta.access.mode on api_key, kun integroit tiliä.

- [Todennus ja kokeilukäyttö](https://www.genderapi.io/fi/docs/v2/authentication)
- [Kaikki pyyntöparametrit](https://www.genderapi.io/fi/docs/v2/request-parameters)

## Sukupuoli sähköpostiosoitteesta

Käytä type: email. API etsii osoitteesta käyttökelpoista nimisignaalia. Jaetut postilaatikot ja läpinäkymättömät paikalliset osat voivat tuottaa tuntemattoman tuloksen. forceToGenderize on valinnainen myös tässä; se sallii tekoälyn päättelemisen aliaksesta jopa ilman oikeaa etunimeä.

Suorita nämä esimerkit palvelimellasi. Aseta GENDERAPI_API_KEY prosessiympäristössä olemassa olevaan API-avaimeen. Varmista, että meta.access.mode on api_key: tunnistamaton avain voi pudota takaisin IP-kokeeseen.

Jokainen ennustepyyntö on uusi laskutettava toiminto, mukaan lukien uudelleenyritykset. Nämä esimerkit eivät yritä automaattisesti uudelleen. Tarkista laskutuksen tila ennen uuden pyynnön lähettämistä.

HTTP 4xx- ja 5xx JSON -vastaukset säilyttävät virheen rungon ja palauttavat nollasta poikkeavan poistumistilan. Tarkista code, action ja meta.usage.billing_status ennen kuin yrität uudelleen.

**cURL**

cURL 7.76+ POSIX-kuoressa. Suorita terminaalissasi.

```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": "email",
  "value": "alice.smith@example.com",
  "country": "US"
}'
```

**JavaScript / Node.js**

Node.js 22+; sisäänrakennettu haku. Tallenna nimellä example.mjs ja suorita 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 body = {
  "type": "email",
  "value": "alice.smith@example.com",
  "country": "US"
};

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+; tavallinen kirjasto. Tallenna nimellä example.py ja suorita 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")
body = json.loads("{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\"}")

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+ cURL-laajennuksella. Tallenna nimellä example.php ja suorita php example.php.

```php
<?php
$apiKey = getenv('GENDERAPI_API_KEY');
if (!$apiKey) {
    throw new RuntimeException('Set GENDERAPI_API_KEY');
}
$body = json_decode('{"type":"email","value":"alice.smith@example.com","country":"US"}', 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+; tavallinen HTTP-asiakas. Tallenna nimellä GenderApiExample.java ja suorita 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");
        String body = "{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\"}";
        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**

.NET 8+ -konsolisovellus. Käytä konsoliprojektissa nimellä Program.cs ja suorita sitten 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.Post, "https://api.genderapi.io/api/v2/gender");
request.Headers.Authorization = new AuthenticationHeaderValue("Bearer", apiKey);
request.Content = new StringContent("{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\"}", 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+; tavallinen kirjasto. Tallenna nimellä main.go ja suorita 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")
    body := "{\"type\":\"email\",\"value\":\"alice.smith@example.com\",\"country\":\"US\"}"
    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)
    }
}
```

## Esimerkkivastauksesta

Tämä synteettinen vaste kuvaa JSON-muotoa, ei mitattua tarkkuutta tai taattua live-tulosta. Se näyttää IP-kokeilukäytön; todennettu toiminta raportoi meta.access.mode: api_key ja null vain kokeiluversion kiintiökentät. Lue tiedot päättelyä varten ja meta.usage saadaksesi toiminnan laskutustuloksen.

```json
{
  "data": {
    "input": {
      "type": "email",
      "value": "alice.smith@example.com",
      "country": "US"
    },
    "name": "alice",
    "gender": "female",
    "country": "US",
    "confidence": 0.9,
    "confidence_kind": "observed_frequency",
    "sample_count": 100,
    "source": "dataset",
    "result_status": "identified",
    "reason": null,
    "country_source": "dataset",
    "match": {
      "name": "alice",
      "method": "normalized",
      "scope": "country",
      "country": "US"
    }
  },
  "meta": {
    "request_id": "11111111-1111-4111-8111-111111111111",
    "duration_ms": 12,
    "access": {
      "mode": "ip_trial",
      "reason": "api_key_missing"
    },
    "usage": {
      "charged_credits": 1,
      "remaining_credits": 9,
      "billing_status": "confirmed",
      "resets_at": "2026-09-26T12:00:00.000Z",
      "limit": 10,
      "period_seconds": 86400
    }
  }
}
```

- [Vastauskentät ja luottamus](https://www.genderapi.io/fi/docs/v2/responses)

## Sähköpostin vahvistus ja nimisignaalit

value:n on oltava syntaktisesti kelvollinen sähköpostiosoite. Virheellinen syntaksi palauttaa HTTP 422 ennen laskutusta. Syntaksin tarkistus ei vahvista, että postilaatikko on olemassa tai kuuluuko se tietylle henkilölle.

Osoitteessa oleva tunnistettava henkilönimi voi vastata tietojoukkoa. Jaetut postilaatikot, rooliosoitteet ja läpinäkymättömät paikalliset osat voivat palauttaa sukupuolen: null. Ratkaisematon yksittäinen haku käyttää oletusarvoisesti tavallista tekoälyn varaosuutta yhdelle kokonaispistemäärälle, mukaan lukien onnistunut tuntematon tulos.

Käytä forceToGenderize: true, jos haluat lempinimen tunnistavan AI-päätelmän, kun tietojoukkoa ei ole ratkaistu. Tämä maksaa 1 hyvityksen ratkaistusta datajoukon tuloksesta tai 2 kokonaismäärää, jos käytetään tekoälyä. API voi silti palauttaa null. Sähköpostin verkkotunnus ei ole todiste henkilön sijainnista. toimittaa maalle vain, kun asiaankuuluva konteksti tunnetaan.

## Aiheeseen liittyviä oppaita

- [AI-tilat ja forceToGenderize](https://www.genderapi.io/fi/docs/v2/ai-options)
- [Eräennusteet](https://www.genderapi.io/fi/docs/v2/batch)
- [Krediitit ja käyttö](https://www.genderapi.io/fi/docs/v2/credits-and-usage)
- [Virheet ja uudelleenyritykset](https://www.genderapi.io/fi/docs/v2/errors-and-retries)