# Wyodrębnianie imienia i sygnału płci z adresu e-mail

> Wyodrębnij kandydata na imię z adresu e-mail i dodaj prognozę wraz z polami źródła do przepływu w Excelu, Google Sheets lub API, nie zastępując danych podanych przez samą osobę.

Canonical HTML: https://www.genderapi.io/pl/blog/wyodrebnianie-imion-z-adresow-email

Last reviewed: 2026-09-28

## Informacje o publikacji

Pierwsza publikacja: 2025-06-14T12:00:00.000Z

Ostatnia weryfikacja: 2026-09-28T00:00:00.000Z

## Czy GenderAPI może wyodrębnić imię z adresu e-mail?

Tak. W przypadku obsługiwanych adresów osobistych może wyodrębnić kandydata na imię z części przed @ i zwrócić dla niego sygnał płci, kontekst kraju i pewność. Jest to wniosek, a nie weryfikacja tożsamości, a adresy ogólne lub losowe mogą pozostać bez wyniku.

- [Demo V2 na żywo i jego opcje](https://www.genderapi.io/pl/blog/wyodrebnianie-imion-z-adresow-email#demo)

## Przeanalizuj adres e-mail

Wyślij wartość i sprawdź pełną odpowiedź, w tym wyniki nieznane i zużyte kredyty.

Zawsze AI (domyślny): 2 kredyty, także przy wyniku unknown. Tryb awaryjny: 1 kredyt, łącznie z przejściem na AI i wynikami unknown. Wyłączony, tylko zbiór danych (bez AI): 1 kredyt za każde zakończone zapytanie, także przy wyniku unknown. Z włączoną analizą pseudonimów: 1 kredyt, jeśli wynik rozstrzygnie zbiór danych, lub łącznie 2, jeśli użyta zostanie AI, także przy wyniku unknown.

Wysłana wartość (pełny adres e-mail) trafia do GenderAPI.io i jest przekazywana do skonfigurowanej usługi AI w domyślnym trybie Zawsze AI lub gdy potrzebne jest przejście na AI, ale nie w trybie Wyłączony. [Szczegóły przetwarzania danych](https://www.genderapi.io/pl/data-provenance).

Ta prawdziwa odpowiedź została pobrana 1 października 2026 r.; zastąpiono jedynie saldo konta. Wartości na żywo mogą się różnić. Prognoza nie jest potwierdzoną tożsamością.

**Prawdziwa odpowiedź V2; pobrana 1 października 2026 r.**

```json
{
  "data": {
    "input": {
      "type": "email",
      "value": "piotr.nowak@example.com",
      "country": null
    },
    "name": "piotr",
    "gender": "male",
    "country": "PL",
    "confidence": 0.98,
    "confidence_kind": "model_reported",
    "sample_count": null,
    "source": "ai",
    "result_status": "identified",
    "reason": null,
    "country_source": "ai_association",
    "match": {
      "name": null,
      "method": "model_inference",
      "scope": null,
      "country": null
    }
  },
  "meta": {
    "request_id": "97b28d48-c07a-425f-8ac9-99309f05d2d8",
    "duration_ms": 381,
    "access": {
      "mode": "api_key",
      "reason": null
    },
    "usage": {
      "charged_credits": 2,
      "remaining_credits": 49999,
      "billing_status": "confirmed",
      "resets_at": null,
      "limit": null,
      "period_seconds": null
    }
  }
}
```

- [załóż konto](https://app.genderapi.io/user/register)

## Od adresu e-mail do uporządkowanych danych

- Dane wejściowe: emilyblack@email.com
- Wyodrębnienie: Emily
- Wzbogacenie: Płeć + pewność

## Wybierz, gdzie przetwarzać dane e-mail

- [Microsoft Excel Zainstaluj dodatek →](https://appsource.microsoft.com/en-us/product/office/WA200008555)
- [Google Sheets Otwórz Marketplace →](https://workspace.google.com/marketplace/app/gender_api_determines_gender_of_name_or/712811575775)
- [Shopify Zobacz aplikację →](https://apps.shopify.com/gender-api)
- [Excel / CSV zbiorczo Otwórz narzędzie →](https://app.genderapi.io/csv)
- [Airtable Zobacz rozszerzenie →](https://airtable.com/marketplace/blkqCasjQIqmmBrmb/gender-api-io-determine-gender)
- [REST API Zobacz endpoint →](https://www.genderapi.io/pl/docs/v2/gender-from-email)

## Przetwarzaj kolumny adresów za pomocą dodatku do Excela

Wybierz metodę dla adresów e-mail, a następnie zmapuj kolumnę źródłową i pola wyników. Użyj GENDER.FROM_EMAIL do dynamicznych zapytań w komórkach lub panelu bocznego do trwałych wyników.

- [Obejrzyj samouczek dla Excela](https://youtu.be/6j4w-3oMZnA)
- [Dodatek GenderAPI do Excela](https://www.genderapi.io/pl/blog/genderize-excel-names-using-genderapi-excel-add-in)
- [Formuły GENDER w Excelu](https://www.genderapi.io/pl/blog/formula-plci-dla-microsoft-excel)

## Analizuj adresy e-mail za pomocą dodatku lub formuły

Użyj dodatku dla istniejących wierszy, obsługiwanego przepływu dla nowych wierszy lub formuły GENDER do zapytań w pojedynczych komórkach.

- [Przewodnik po dodatku](https://www.genderapi.io/pl/blog/jak-okreslic-plec-w-google-sheets-za-pomoca-gender-api-add-on)
- [Formuła GENDER w Google Sheets](https://www.genderapi.io/pl/blog/formula-plec-google-sheets-wykryj-plec-na-podstawie-imion)

## Dodaj analizę adresów e-mail w swoim backendzie

Wywołuj uwierzytelniony endpoint dla adresów e-mail z serwera, nie ujawniając klucza API w przeglądarce ani w publicznym kodzie. Jawnie obsługuj schemat odpowiedzi, kody błędów i zużycie kredytów.

Zrzut ekranu wyników starszej integracji; nie przedstawia obecnego kontraktu odpowiedzi V2.

- [Pojedyncze zapytanie o adres e-mail](https://www.genderapi.io/pl/docs/v2/gender-from-email)
- [Zapytanie o wiele adresów e-mail](https://www.genderapi.io/pl/docs/v2/batch)

## Nie wymuszaj wyniku, gdy adres nie zawiera imienia

Adresy funkcyjne, losowe identyfikatory i współdzielone skrzynki mogą nie dać wiarygodnego sygnału. Zachowaj data.result_status, data.reason i data.confidence oraz obsługuj niepewne wyniki osobno.

Dopasowanie w adresie e-mail nie potwierdza tożsamości ani imienia właściciela skrzynki. Mierz jakość na własnym zbiorze danych i nie opieraj żadnej decyzji o dużym wpływie na konkretną osobę wyłącznie na tej prognozie.

## Przechowuj dane źródłowe i prognozę osobno

Zachowaj oryginalny identyfikator rekordu. API nie otwiera żadnego profilu, nie weryfikuje, do kogo należy konto, ani nie potwierdza niczyjej tożsamości. Kontekst kraju wysyłaj tylko wtedy, gdy masz wiarygodną informację; nie wyprowadzaj go z domeny ani z języka strony.

Wyszukiwanie w zbiorze danych analizuje część przed @, usuwa przyrostek zaczynający się od + i ocenia kandydatów na imię. Standardowe zapytanie może też dodać ograniczoną liczbę kandydatów według prefiksu i sufiksu w połączonych częściach. Jeśli pasuje kilka rekordów, wybierany jest ten z najwyższą zarejestrowaną liczebnością; ten kandydat nie musi być prawdziwym imieniem osoby. Jeśli wyślesz kraj, dla każdego kandydata preferowany jest rekord tego kraju, a w razie jego braku może zostać użyty rekord globalny. Sprawdź data.match.scope i country_source.

| Rekord | Pole | Jak interpretować |
| --- | --- | --- |
| Rekord źródłowy | contact_id / original_email | Przechowuj dane źródłowe we własnej aplikacji i nie zastępuj imienia podanego przez osobę prognozą. Nie są to pola odpowiedzi API. |
| Kandydat na imię | data.name / data.match | Wybrane imię może mieć wartość null. Nie ma pola ze zweryfikowanym nazwiskiem, a dopasowanie nie dowodzi tożsamości właściciela skrzynki. |
| Prognoza | data.gender / data.result_status / data.reason | Wynik nieznany zapisuj jako natywny null JSON. Rekord zbioru danych z remisem może zawierać kandydata na imię bez płci. |
| Dowody | data.source / data.confidence_kind / data.confidence / data.sample_count | confidence przyjmuje wartości od 0 do 1. Częstość w zbiorze danych i wynik AI to różne miary; przy AI sample_count ma wartość null. |
| Dziennik operacji | meta.request_id / meta.usage | Zachowaj identyfikator i status rozliczenia; utracona odpowiedź nie oznacza, że operacja była bezpłatna ani że się nie powiodła. |

### Wybierz tryb przetwarzania i jego koszt w kredytach

W pojedynczym zapytaniu wartością domyślną jest fallback, a w elementach partii off. forceToGenderize jest opcjonalne dla imion, adresów e-mail i nazw użytkowników; w takim przypadku pomiń ai_mode lub użyj fallback, ponieważ ta opcja nie jest zgodna z off i always. Udane wyniki unknown również są rozliczane. Do rozpoczęcia wystarczy dodatnie saldo początkowe; po zakończeniu operacji saldo może spaść poniżej zera.

Jeśli użyta zostanie AI, otrzymuje ona cały wysłany adres, łącznie z domeną i przyrostkiem +, nawet jeśli jest instruowana, aby pominąć te części. forceToGenderize może zwrócić powiązanie z płcią bez znalezienia prawdziwego imienia; nie oznacza to, że do Twojego CRM wyodrębniono zweryfikowane imię.

| Opcja | Przetwarzanie | Koszt za udany element |
| --- | --- | --- |
| options.ai_mode: off | Tylko zbiór danych | 1 kredyt |
| options.ai_mode: fallback | Najpierw zbiór danych, a jeśli płeć nie zostanie ustalona, standardowa AI | Łącznie 1 kredyt, wraz z AI |
| options.ai_mode: always | Bezpośrednio AI | 2 kredyty |
| forceToGenderize: true | Najpierw zbiór danych, a następnie interpretacja pseudonimu bez wymogu prawdziwego imienia | 1, jeśli wystarczy zbiór danych; łącznie 2, jeśli użyto AI |

### Najpierw sprawdź zapytanie o adres e-mail tylko ze zbiorem danych

Przykładowe dane wejściowe nie gwarantują żadnej konkretnej prognozy. Ustaw GENDERAPI_API_KEY w środowisku serwera i nie umieszczaj klucza w publicznym kodzie po stronie klienta. V1 i V2 korzystają z tego samego klucza konta i tego samego salda. Sprawdź klucz za pomocą /api/v2/usage i upewnij się, że meta.access.mode ma wartość api_key.

Wybierz język programowania. [Skonfiguruj klucz API](https://www.genderapi.io/pl/docs/v2/authentication#environment-setup), następnie uruchom przykład na swoim serwerze.

Każde zapytanie o prognozę, łącznie z ponownymi próbami, jest nową płatną operacją. Te przykłady nie ponawiają zapytań automatycznie. Przed wysłaniem kolejnego zapytania sprawdź status rozliczenia.

### Zanim uruchomisz: dostęp i obsługa błędów

Uruchamiaj te przykłady na swoim serwerze. Ustaw w środowisku procesu zmienną GENDERAPI_API_KEY na swój istniejący klucz API. Upewnij się, że meta.access.mode ma wartość api_key: nierozpoznany klucz może spowodować przejście na próbę dla adresu IP.

W przypadku odpowiedzi JSON z kodem HTTP 4xx i 5xx przykłady zachowują treść błędu i zwracają niezerowy kod wyjścia. Przed ponowną próbą sprawdź code, action i meta.usage.billing_status.

**cURL**

cURL 7.76+ w powłoce POSIX. Uruchom w terminalu. [Dokumentacja środowiska uruchomieniowego](https://curl.se/docs/manpage.html)

```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",
  "options": {
    "ai_mode": "off"
  }
}'
```

**JavaScript / Node.js**

Node.js 22+; wbudowany fetch. Zapisz jako example.mjs i uruchom node example.mjs. [Dokumentacja środowiska uruchomieniowego](https://nodejs.org/api/globals.html#fetch)

```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",
  "options": {
    "ai_mode": "off"
  }
};

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+; biblioteka standardowa. Zapisz jako example.py i uruchom python3 example.py. [Dokumentacja środowiska uruchomieniowego](https://docs.python.org/3/library/urllib.request.html)

```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\",\"options\":{\"ai_mode\":\"off\"}}")

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+ z rozszerzeniem cURL. Zapisz jako example.php i uruchom php example.php. [Dokumentacja środowiska uruchomieniowego](https://www.php.net/manual/en/book.curl.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","options":{"ai_mode":"off"}}', 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+; standardowy klient HTTP. Zapisz jako GenderApiExample.java i uruchom java GenderApiExample.java. [Dokumentacja środowiska uruchomieniowego](https://docs.oracle.com/en/java/javase/17/docs/api/java.net.http/java/net/http/HttpClient.html)

```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\",\"options\":{\"ai_mode\":\"off\"}}";
        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**

Aplikacja konsolowa .NET 8+. Użyj jako Program.cs w projekcie konsolowym, a następnie uruchom dotnet run. [Dokumentacja środowiska uruchomieniowego](https://learn.microsoft.com/en-us/dotnet/fundamentals/networking/http/httpclient)

```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\",\"options\":{\"ai_mode\":\"off\"}}", 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+; biblioteka standardowa. Zapisz jako main.go i uruchom go run main.go. [Dokumentacja środowiska uruchomieniowego](https://pkg.go.dev/net/http)

```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\",\"options\":{\"ai_mode\":\"off\"}}"
    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)
    }
}
```

- [Przewodnik po błędach i ponawianiu zapytań →](https://www.genderapi.io/pl/docs/v2/errors-and-retries)

### Obsługuj wyniki listy i ponowne próby

POST /api/v2/gender/batch przyjmuje do 50 elementów z kluczem API i 10 w ramach próby dla adresu IP. Każdemu elementowi przypisz własne type, value i options. Jeśli chcesz używać standardowego przejścia na AI, ustaw fallback jawnie w każdym elemencie. id musi być unikalne w obrębie partii; index zaczyna się od zera w wysłanej partii. Własne identyfikatory zadania i wiersza źródłowego przechowuj osobno.

Kod HTTP 200 nie oznacza, że wszystkie elementy zakończyły się powodzeniem. Wyniki identified, unknown i error obsługuj osobno; meta.summary.succeeded liczy zarówno identified, jak i unknown. Oceniaj łącznie data.gender, source, confidence_kind, confidence, match i reason. Nie traktuj wyniku AI i częstości w zbiorze danych jako równoważnych.

Jeśli meta.usage.billing_status ma wartość confirmed, ponawiaj tylko te błędy operacyjne, które dopuszczają ponowną próbę. Jeśli status to unconfirmed lub odpowiedź została utracona, zatrzymaj się i uzgodnij rozliczenie. Ponowne wysłanie tego samego rekordu, także udanego wyniku unknown, tworzy nową płatną operację; nigdy nie wysyłaj ponownie całej listy na ślepo.

[Kontrakt zapytań zbiorczych](https://www.genderapi.io/pl/docs/v2/batch) · [Pola odpowiedzi](https://www.genderapi.io/pl/docs/v2/responses) · [Opcje AI](https://www.genderapi.io/pl/docs/v2/ai-options) · [Ocena dokładności i pewności](https://www.genderapi.io/pl/accuracy-methodology) · [Polityka prywatności](https://www.genderapi.io/pl/privacy-policy)

Dodatki do Excela i Google Sheets oraz inne gotowe integracje mogą korzystać z własnego połączenia i własnego formatu wyników. Nie zakładaj, że ich wynik jest zgodny z tym schematem JSON V2; sprawdź aktualny przewodnik każdej integracji.

## Imię i płeć z adresu e-mail

### Czy można wyodrębnić imię z adresu e-mail?

GenderAPI może wyodrębnić kandydata na imię z części przed @ w obsługiwanych adresach osobistych i zwrócić, jeśli są dostępne, sygnały płci, kraju i pewności. Taki kandydat jest wnioskiem, a nie zweryfikowanym imieniem właściciela skrzynki.

### Czy z każdego adresu można uzyskać imię?

Nie. Adresy funkcyjne, losowe identyfikatory i części lokalne bez prawdziwego imienia mogą nie dać wiarygodnego sygnału. W odpowiedzi V2 sprawdź data.result_status, data.reason, data.confidence i data.confidence_kind.

### Czy zapytania o adresy e-mail są przechowywane?

Zgodnie z opublikowaną polityką zapytania o adresy e-mail nie są przechowywane jako rekordy zapytań do ponownego wykorzystania. Odrębne logi techniczne i bezpieczeństwa podlegają okresom opisanym w polityce prywatności. Nie używaj w publicznej wersji demonstracyjnej wrażliwych danych osobowych.

### Czy mogę używać tej funkcji w Excelu i Google Sheets?

Tak. Kolumny adresów możesz przetwarzać za pomocą dodatku do Excela, dodatku do Google Sheets lub narzędzia do importu plików Excel i CSV. Te integracje mają własny format wyników, inny niż JSON V2.

### Jakie pola zwraca API?

V2 zwraca data.name, data.gender, data.match oraz pola źródła i pewności, a w meta identyfikator operacji i zużycie kredytów. Kandydat na imię lub płeć mogą mieć wartość null. Nie ma pola ze zweryfikowanym nazwiskiem.

### Kiedy używana jest AI?

W pojedynczym zapytaniu V2 standardowe przejście na AI jest domyślnie włączone. W tej wersji demonstracyjnej możesz użyć standardowego zapytania lub forceToGenderize; off i always ustawia się w zapytaniu do API. Standardowe przejście na AI kosztuje łącznie 1 kredyt, a always 2. Przy forceToGenderize pobierany jest 1 kredyt, jeśli zbiór danych rozstrzygnie zapytanie, lub łącznie 2, jeśli użyto AI; wynik może pozostać unknown.

### Czy mogę przetestować usługę bezpłatnie?

Konta obejmują 200 bezpłatnych kredytów dziennie, a współdzielona próba dla adresu IP 10 kredytów dziennie. Brakujący lub nierozpoznany klucz może spowodować przejście na próbę dla adresu IP; sprawdź pole meta.access.mode w odpowiedzi. Są to kredyty, a nie liczba zapytań.
