# Trekk ut et kandidatnavn og et kjønnssignal fra en e-postadresse

> Trekk ut et kandidatnavn fra en e-postadresse, og legg estimatene og de tilhørende kildefeltene til i arbeidsflyten i Excel, Google Sheets eller API-et uten å endre det personen selv har oppgitt.

Canonical HTML: https://www.genderapi.io/nb/blog/extract-names-from-email-addresses

Last reviewed: 2026-09-30

## Publiseringsinformasjon

Først publisert: 2025-07-16T12:00:00.000Z

Sist gjennomgått: 2026-09-30T00:00:00.000Z

## Kan GenderAPI trekke ut et navn fra en e-postadresse?

Ja. For støttede personlige e-postadresser trekker GenderAPI ut et kandidatnavn fra delen før @ og returnerer et kjønnssignal, landkontekst og konfidens. Dette er et estimat, ikke en bekreftelse av identitet. Delte eller tilfeldige adresser gir kanskje ikke noe resultat.

- [Direkte V2-demo og alternativer](https://www.genderapi.io/nb/blog/extract-names-from-email-addresses#demo)

## Analyser en e-postadresse

Send en verdi og se hele svaret, inkludert ukjente resultater og brukte kreditter.

Alltid KI (standard): 2 kreditter, også når resultatet er ukjent. Reserve: 1 kreditt, inkludert KI-reserve og ukjente resultater. Av, bare datasett (uten KI): 1 kreditt per fullført forespørsel, også når resultatet er ukjent. Med tolkning av kallenavn: 1 kreditt hvis resultatet kommer fra datasettet, eller 2 kreditter totalt hvis KI brukes, også når resultatet er ukjent.

Verdien du sender (hele e-postadressen), overføres til GenderAPI.io og videresendes til den konfigurerte KI-tjenesten i modusen Alltid KI (standard) eller hvis KI-reserve trengs, men ikke i modusen Av. [Les mer om hvordan dataene behandles](https://www.genderapi.io/nb/data-provenance).

Dette ekte svaret ble hentet 1. oktober 2026; bare kontosaldoen er erstattet. Verdier i sanntid kan være annerledes. En prediksjon er ikke en bekreftet identitet.

**Ekte V2-svar; hentet 1. oktober 2026**

```json
{
  "data": {
    "input": {
      "type": "email",
      "value": "ole.hansen@example.com",
      "country": null
    },
    "name": "ole",
    "gender": "male",
    "country": null,
    "confidence": 0.98,
    "confidence_kind": "model_reported",
    "sample_count": null,
    "source": "ai",
    "result_status": "identified",
    "reason": null,
    "country_source": null,
    "match": {
      "name": null,
      "method": "model_inference",
      "scope": null,
      "country": null
    }
  },
  "meta": {
    "request_id": "5be79192-f773-4a22-b583-2c6932639c40",
    "duration_ms": 372,
    "access": {
      "mode": "api_key",
      "reason": null
    },
    "usage": {
      "charged_credits": 2,
      "remaining_credits": 49999,
      "billing_status": "confirmed",
      "resets_at": null,
      "limit": null,
      "period_seconds": null
    }
  }
}
```

- [opprett en konto](https://app.genderapi.io/user/register)

## Fra e-postadresse til strukturerte data

- Inndata: emilyblack@email.com
- Uttrukket navn: Emily
- Berikelse: Kjønn + konfidens

## Velg hvor e-postdataene skal behandles

- [Microsoft Excel Installer tillegget →](https://appsource.microsoft.com/en-us/product/office/WA200008555)
- [Google Sheets Åpne Marketplace →](https://workspace.google.com/marketplace/app/gender_api_for_google_sheets_determines/712811575775)
- [Shopify Se appen →](https://apps.shopify.com/gender-api)
- [Massebehandling av Excel/CSV Åpne filverktøyet →](https://app.genderapi.io/csv)
- [Airtable Se utvidelsen →](https://airtable.com/marketplace/blkqCasjQIqmmBrmb/gender-api-io-determine-gender)
- [REST API Se endepunktet →](https://www.genderapi.io/nb/docs/v2/gender-from-email)

## Behandle en kolonne med e-postadresser med Excel-tillegget

Velg metoden for e-postadresser, og tilordne deretter inndatakolonnen og resultatkolonnene. Bruk GENDER.FROM_EMAIL for dynamiske oppslag per celle, eller sidepanelet når resultatene skal skrives inn som faste verdier.

- [Se Excel-videoguiden](https://youtu.be/6j4w-3oMZnA)
- [Veiledning for GenderAPI-tillegget i Excel](https://www.genderapi.io/nb/blog/genderize-excel-names-using-genderapi-excel-add-in)
- [GENDER-formelen i Excel](https://www.genderapi.io/nb/blog/gender-formula-for-microsoft-excel)

## Analyser e-postadresser med tillegget eller en formel

Bruk tillegget for eksisterende rader, den tilsvarende arbeidsflyten for nye rader og formelen GENDER for oppslag fra én celle.

- [Veiledning for Google Sheets-tillegget](https://www.genderapi.io/nb/blog/how-to-determine-gender-in-google-sheets-using-gender-api-add-on)
- [GENDER-formelen i Google Sheets](https://www.genderapi.io/nb/blog/gender-formula-google-sheets-detect-gender-from-names)

## Legg til analyse av e-postadresser på serveren din

Kall det dokumenterte endepunktet for e-postadresser fra serveren, og ikke legg API-nøkkelen i nettleseren eller i offentlig kode. Håndter svarstrukturen, feilkodene og kredittforbruket uttrykkelig.

Bildet viser resultatet fra en tidligere integrasjon og gjengir ikke de gjeldende svarreglene i V2.

- [Forespørsel med én e-postadresse](https://www.genderapi.io/nb/docs/v2/gender-from-email)
- [Forespørsel med flere e-postadresser](https://www.genderapi.io/nb/docs/v2/batch)

## Ikke tving frem et resultat når adressen mangler et navn

Rolleadresser, tilfeldige identifikatorer og delte innbokser gir ikke alltid et pålitelig signal. Behold data.result_status, data.reason og data.confidence, og håndter usikre resultater for seg.

Et treff fra en e-postadresse bekrefter verken identiteten eller navnet til den som eier adressen. Mål kvaliteten på dine egne data, og ikke ta beslutninger med stor betydning for en person bare på grunnlag av dette estimatet.

## Lagre kildedata og estimat hver for seg

Behold den opprinnelige identifikatoren for posten. API-et åpner ingen profil, kontrollerer ikke hvem som eier en konto, og bekrefter ingen identitet. Send bare landkontekst når du har pålitelig informasjon, og ikke utled den fra domenet eller språket på nettstedet.

Oppslaget i datasettet analyserer delen før @, fjerner et suffiks som begynner med +, og vurderer kandidatnavnene. En standardforespørsel kan i tillegg legge til et begrenset antall kandidater fra begynnelsen og slutten av sammensatte deler. Hvis flere rader gir treff, velges raden med flest registrerte forekomster; den kandidaten er ikke nødvendigvis personens egentlige navn. Hvis du sender et land, foretrekkes landets rad for hver kandidat; mangler den, kan en global rad brukes. Kontroller data.match.scope og country_source.

| Post | Felt | Tolkning |
| --- | --- | --- |
| Kildepost | contact_id / original_email | Behold kildedataene i ditt eget system, og ikke erstatt et navn personen selv har oppgitt, med estimatet. Dette er ikke felt i API-svaret. |
| Kandidatnavn | data.name / data.match | Det valgte navnet kan være null. Det finnes ikke noe felt for et verifisert etternavn, og et treff beviser ikke hvem som eier innboksen. |
| Estimat | data.gender / data.result_status / data.reason | Lagre et ukjent resultat som JSON-verdien null. En rad i datasettet med like mange forekomster kan gi et kandidatnavn uten kjønn. |
| Grunnlag | data.source / data.confidence_kind / data.confidence / data.sample_count | confidence ligger mellom 0 og 1. Frekvens i datasettet og en KI-verdi måler ulike ting; for KI er sample_count null. |
| Logg over behandlingen | meta.request_id / meta.usage | Lagre ID-en og belastningsstatusen. Et tapt svar betyr verken at behandlingen var gratis, eller at den mislyktes. |

### Velg behandlingsmodus og kostnad i kreditter

Standard for en enkeltforespørsel er fallback, og for elementer i en samleforespørsel er det off. forceToGenderize er valgfritt for navn, e-postadresser og brukernavn; utelat da ai_mode eller bruk fallback, fordi alternativet ikke kan kombineres med off og always. Fullførte unknown-resultater belastes også. En positiv saldo er nok til å starte, og etter at behandlingen er fullført, kan saldoen bli negativ.

Når KI brukes, mottar den hele adressen du sendte, inkludert domenet og suffikset etter +, selv om den blir bedt om å se bort fra disse delene. Med forceToGenderize kan et kjønn returneres uten at et ekte fornavn er funnet; det betyr ikke at et verifisert navn er trukket ut til CRM-systemet ditt.

| Alternativ | Behandling | Kreditter per fullført element |
| --- | --- | --- |
| options.ai_mode: off | Bare datasettet | 1 kreditt |
| options.ai_mode: fallback | Først datasettet; vanlig KI-reserve hvis kjønnet ikke kan bestemmes | 1 kreditt totalt, inkludert KI |
| options.ai_mode: always | Direkte til KI | 2 kreditter |
| forceToGenderize: true | Først datasettet, deretter tolkning av kallenavnet uten krav om et ekte fornavn | 1 hvis datasettet er nok, 2 totalt hvis KI brukes |

### Test først en e-postforespørsel som bare bruker datasettet

Eksempler på inndata garanterer ikke et bestemt estimat. Sett GENDERAPI_API_KEY i servermiljøet, og ikke legg nøkkelen i offentlig kode på klientsiden. V1 og V2 bruker samme API-nøkkel og samme kontosaldo. Kontroller nøkkelen med /api/v2/usage, og bekreft at meta.access.mode har verdien api_key.

Velg et programmeringsspråk. [Konfigurer API-nøkkelen](https://www.genderapi.io/nb/docs/v2/authentication#environment-setup), og kjør deretter eksemplet på serveren din.

Hver prediksjonsforespørsel er en ny operasjon som belastes, også nye forsøk. Disse eksemplene prøver ikke automatisk på nytt. Sjekk belastningsstatusen før du sender en ny forespørsel.

### Før du kjører: tilgang og feilhåndtering

Kjør disse eksemplene på serveren din. Sett GENDERAPI_API_KEY i prosessmiljøet til din eksisterende API-nøkkel. Bekreft at meta.access.mode er api_key: en nøkkel som ikke gjenkjennes, kan føre til IP-prøveperioden.

Ved JSON-svar med HTTP 4xx og 5xx beholdes feilinnholdet, og eksemplet avsluttes med en exit-status som ikke er null. Sjekk code, action og meta.usage.billing_status før du prøver på nytt.

**cURL**

cURL 7.76+ i et POSIX-skall. Kjør i terminalen. [Dokumentasjon for kjøretidsmiljøet](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+; innebygd fetch. Lagre som example.mjs og kjør node example.mjs. [Dokumentasjon for kjøretidsmiljøet](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+; standardbiblioteket. Lagre som example.py og kjør python3 example.py. [Dokumentasjon for kjøretidsmiljøet](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+ med cURL-utvidelsen. Lagre som example.php og kjør php example.php. [Dokumentasjon for kjøretidsmiljøet](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+; standard HTTP-klient. Lagre som GenderApiExample.java og kjør java GenderApiExample.java. [Dokumentasjon for kjøretidsmiljøet](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**

Konsollapplikasjon i .NET 8+. Bruk som Program.cs i et konsollprosjekt, og kjør deretter dotnet run. [Dokumentasjon for kjøretidsmiljøet](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+; standardbiblioteket. Lagre som main.go og kjør go run main.go. [Dokumentasjon for kjøretidsmiljøet](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)
    }
}
```

- [Veiledning om feil og nye forsøk →](https://www.genderapi.io/nb/docs/v2/errors-and-retries)

### Håndter resultater fra lister og nye forsøk

POST /api/v2/gender/batch godtar opptil 50 elementer med en API-nøkkel og 10 i IP-prøveperioden. Gi hvert element egne verdier for type, value og options. Hvis du vil bruke vanlig KI-reserve, må du angi fallback uttrykkelig i hvert element. id må være unik i samleforespørselen, og index begynner på null i den innsendte samleforespørselen. Lagre dine egne jobb- og kilderad-ID-er separat.

HTTP 200 betyr ikke at alle elementer er fullført. Håndter resultatene identified, unknown og error hver for seg; meta.summary.succeeded teller både identified og unknown. Vurder data.gender, source, confidence_kind, confidence, match og reason samlet, og ikke behandle en KI-verdi og en frekvens i datasettet som det samme.

Hvis meta.usage.billing_status har verdien confirmed, skal du bare gjenta feilene som tillater et nytt forsøk. Hvis statusen er unconfirmed, eller svaret har gått tapt, må du stoppe og kontrollere belastningen. Hvis du sender det samme elementet på nytt, også et fullført unknown-resultat, belastes det som en ny handling; send aldri hele listen på nytt uten kontroll.

[Regler for samleforespørsler](https://www.genderapi.io/nb/docs/v2/batch) · [Svarfelt](https://www.genderapi.io/nb/docs/v2/responses) · [KI-alternativer](https://www.genderapi.io/nb/docs/v2/ai-options) · [Vurdering av nøyaktighet og konfidens](https://www.genderapi.io/nb/accuracy-methodology) · [Personvernerklæring](https://www.genderapi.io/nb/privacy-policy)

Tilleggene for Excel og Google Sheets og de andre ferdige integrasjonene kan bruke egen tilkobling og eget resultatformat. Ikke gå ut fra at utdataene deres følger dette V2-JSON-skjemaet; les den gjeldende veiledningen for den aktuelle integrasjonen.

## Navn og kjønn fra en e-postadresse

### Kan et navn trekkes ut fra en e-postadresse?

For støttede personlige adresser kan GenderAPI trekke ut et kandidatnavn fra delen før @ og, når det finnes et resultat, returnere kjønn, land og konfidens. Kandidatnavnet er et estimat og ikke et verifisert navn på den som eier innboksen.

### Gir alle e-postadresser et navn?

Nei. Rolleadresser, tilfeldige identifikatorer og lokale deler uten et ekte navn gir ikke alltid et pålitelig signal. Kontroller data.result_status, data.reason, data.confidence og data.confidence_kind i V2-svaret.

### Blir e-postforespørsler lagret?

Ifølge den publiserte policyen lagres e-postforespørsler ikke som gjenbrukbare forespørselsposter. Separate tekniske logger og sikkerhetslogger følger lagringsperiodene i personvernerklæringen. Ikke bruk sensitive personopplysninger i den offentlige demoen.

### Kan jeg bruke dette i Excel og Google Sheets?

Ja. Kolonner med e-postadresser kan behandles med Excel-tillegget, Google Sheets-tillegget eller filverktøyet for Excel og CSV. Disse integrasjonene har sitt eget resultatformat, som er forskjellig fra V2-JSON.

### Hvilke felt returnerer API-et?

V2 returnerer data.name, data.gender, data.match og feltene for kilde og konfidens, og i meta også forespørsels-ID og kredittforbruk. Kandidatnavnet eller kjønnet kan være null. Det finnes ikke noe felt for et verifisert etternavn.

### Når brukes KI?

For en enkeltforespørsel i V2 er vanlig KI-reserve slått på som standard. I denne demoen kan du bruke en standardforespørsel eller forceToGenderize; off og always angir du i API-forespørselen. Vanlig KI-reserve koster 1 kreditt totalt, always koster 2. Med forceToGenderize koster et resultat fra datasettet 1 kreditt og et resultat med KI 2 kreditter totalt, og resultatet kan fortsatt være unknown.

### Kan jeg teste gratis?

En konto får 200 gratis kreditter per dag, og den delte IP-prøveperioden gir 10 kreditter per offentlig IP-adresse hver 24. time. En manglende eller ukjent nøkkel kan føre til IP-prøveperioden, så kontroller meta.access.mode i svaret. Det er kreditter som telles, ikke antall forespørsler.