# Udtræk et navn og et kønssignal fra en e-mailadresse

> Udtræk et kandidatnavn fra en e-mailadresse, og supplér din arbejdsgang i Excel, Google Sheets eller API'et med forudsigelsen og de tilhørende kildefelter uden at erstatte de oplysninger, personen selv har givet.

Canonical HTML: https://www.genderapi.io/da/blog/udtraek-navne-fra-email-adresser

Last reviewed: 2026-09-29

## Udgivelsesoplysninger

Først udgivet: 2025-06-14T12:00:00.000Z

Senest gennemgået: 2026-09-29T00:00:00.000Z

## Kan GenderAPI udtrække et navn fra en e-mailadresse?

Ja. For understøttede personlige adresser kan GenderAPI udtrække et kandidatnavn fra delen før @ og returnere et kønssignal, landekontekst og konfidens. Det er en slutning, ikke en verificering af identiteten, og generiske eller tilfældige adresser kan forblive uden resultat.

- [Livedemo af V2 og dens indstillinger](https://www.genderapi.io/da/blog/udtraek-navne-fra-email-adresser#demo)

## Analysér en e-mailadresse

Send en værdi, og se hele svaret, inklusive ukendte resultater og brugte kreditter.

Altid AI (standard): 2 kreditter, også når resultatet er ukendt. Fallback: 1 kredit, inklusive automatisk AI-fallback og ukendte resultater. Fra, kun datasæt (uden AI): 1 kredit pr. gennemført forespørgsel, også når resultatet er ukendt. Med fortolkning af kaldenavne: 1 kredit, hvis resultatet kommer fra datasættet, eller 2 i alt, hvis AI bruges, også når resultatet er ukendt.

Den sendte værdi (hele e-mailadressen) sendes til GenderAPI.io og videregives til den konfigurerede AI-tjeneste i tilstanden Altid AI (standard), eller når der er brug for AI-fallback, men ikke i tilstanden Fra. [Læs mere om behandlingen af data](https://www.genderapi.io/da/data-provenance).

Dette rigtige svar blev hentet den 1. oktober 2026; kun kontosaldoen er erstattet. Live-værdier kan være anderledes. En forudsigelse er ikke en bekræftet identitet.

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

```json
{
  "data": {
    "input": {
      "type": "email",
      "value": "anders.jensen@example.com",
      "country": null
    },
    "name": "anders",
    "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": "74947fb3-196c-4b44-a206-4f63e78a494f",
    "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
    }
  }
}
```

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

## Fra e-mailadresse til strukturerede data

- Input: emilyblack@email.com
- Udtræk: Emily
- Berigelse: Køn + konfidens

## Vælg, hvor e-maildataene skal behandles

- [Microsoft Excel Installér tilføjelsen →](https://appsource.microsoft.com/en-us/product/office/WA200008555)
- [Google Sheets Åbn Marketplace →](https://workspace.google.com/marketplace/app/gender_api_determines_gender_of_name_or/712811575775)
- [Shopify Se appen →](https://apps.shopify.com/gender-api)
- [Excel / CSV i batch Åbn værktøjet →](https://app.genderapi.io/csv)
- [Airtable Se udvidelsen →](https://airtable.com/marketplace/blkqCasjQIqmmBrmb/gender-api-io-determine-gender)
- [REST API Se endpointet →](https://www.genderapi.io/da/docs/v2/gender-from-email)

## Behandl kolonner med adresser med tilføjelsen til Excel

Vælg metoden til e-mailadresser, og tilknyt derefter kildekolonnen og resultatfelterne. Brug GENDER.FROM_EMAIL til dynamiske opslag i celler eller sidepanelet til varige resultater.

- [Se videovejledningen til Excel](https://youtu.be/6j4w-3oMZnA)
- [GenderAPI-tilføjelsen til Excel](https://www.genderapi.io/da/blog/genderize-excel-names-using-genderapi-excel-add-in)
- [GENDER-formler i Excel](https://www.genderapi.io/da/blog/gender-formel-til-microsoft-excel)

## Analysér e-mailadresser med tilføjelsen eller en formel

Brug tilføjelsen til eksisterende rækker, en understøttet arbejdsgang til nye rækker eller formlen GENDER til opslag i enkelte celler.

- [Guide til tilføjelsen](https://www.genderapi.io/da/blog/hvordan-bestemmes-koen-i-google-sheets-med-gender-api-add-on)
- [GENDER-formlen i Google Sheets](https://www.genderapi.io/da/blog/koensformel-google-sheets-bestem-koen-ud-fra-navne)

## Integrér analysen af e-mailadresser i dit backend

Kald det godkendte endpoint for e-mailadresser fra serveren uden at eksponere API-nøglen i browseren eller i offentlig kode. Håndtér svarskemaet, fejlkoderne og forbruget af kreditter eksplicit.

Skærmbillede af resultater fra en tidligere integration; det viser ikke den aktuelle V2-svarkontrakt.

- [Enkeltforespørgsel for en e-mailadresse](https://www.genderapi.io/da/docs/v2/gender-from-email)
- [Forespørgsel for flere e-mailadresser](https://www.genderapi.io/da/docs/v2/batch)

## Fremtving ikke et resultat, når adressen ikke indeholder et navn

Funktionsadresser, tilfældige identifikatorer og delte postkasser giver ikke altid et pålideligt signal. Bevar data.result_status, data.reason og data.confidence, og håndtér usikre resultater separat.

Et match i en e-mailadresse bekræfter hverken identiteten eller navnet på den, der ejer postkassen. Mål kvaliteten på dine egne data, og basér ikke en beslutning med stor betydning for en enkelt person alene på denne forudsigelse.

## Gem kildedata og forudsigelse hver for sig

Bevar postens oprindelige identifikator. API'et åbner ingen profil, kontrollerer ikke, hvem der ejer en konto, og bekræfter ikke nogen identitet. Send kun en landekontekst, når du har en pålidelig oplysning; udled den ikke af domænet eller af webstedets sprog.

Opslaget i datasættet analyserer delen før @, fjerner et suffiks, der begynder med +, og vurderer kandidatnavnene. En standardforespørgsel kan desuden tilføje et begrænset antal kandidater ud fra præfiks og suffiks i sammensatte dele. Hvis flere rækker matcher, vælges den med det højeste antal registrerede forekomster; den kandidat er ikke nødvendigvis personens rigtige navn. Hvis du sender et land, foretrækkes landets række for hver kandidat; mangler den, kan en global række bruges. Kontrollér data.match.scope og country_source.

| Post | Felt | Fortolkning |
| --- | --- | --- |
| Kildepost | contact_id / original_email | Bevar kildedataene i dit eget system, og erstat ikke et navn, som personen selv har oplyst, med forudsigelsen. Det er ikke felter i API-svaret. |
| Kandidatnavn | data.name / data.match | Det valgte navn kan være null. Der findes ikke et felt til et verificeret efternavn, og et match beviser ikke, hvem der ejer postkassen. |
| Forudsigelse | data.gender / data.result_status / data.reason | Gem et ukendt resultat som JSON-null. En uafgjort række i datasættet kan indeholde et kandidatnavn uden køn. |
| Evidens | data.source / data.confidence_kind / data.confidence / data.sample_count | confidence ligger mellem 0 og 1. Hyppighed i datasættet og en AI-score er forskellige mål; for AI er sample_count null. |
| Log over operationen | meta.request_id / meta.usage | Gem id'et og opkrævningsstatussen; et tabt svar betyder hverken, at operationen var gratis, eller at den mislykkedes. |

### Vælg behandlingstilstand og pris i kreditter

For en enkeltforespørgsel er standarden fallback, for elementer i en batch off. forceToGenderize er valgfrit for navne, e-mailadresser og brugernavne; udelad i så fald ai_mode, eller brug fallback, fordi indstillingen ikke kan kombineres med off og always. Gennemførte unknown-resultater opkræves også. En positiv startsaldo er nok til at gå i gang; når operationen er afsluttet, kan saldoen blive negativ.

Når AI bruges, modtager den hele den adresse, du har sendt, inklusive domænet og +-suffikset, også selvom den bliver bedt om at se bort fra de dele. forceToGenderize kan give en kobling til et køn, uden at der er fundet et egentligt fornavn; det betyder ikke, at der er udtrukket et verificeret navn i dit CRM.

| Indstilling | Behandling | Pris pr. gennemført element |
| --- | --- | --- |
| options.ai_mode: off | Kun datasættet | 1 kredit |
| options.ai_mode: fallback | Først datasættet; hvis der ikke kan bestemmes et køn, almindelig AI-fallback | 1 kredit i alt, inklusive AI |
| options.ai_mode: always | Direkte til AI | 2 kreditter |
| forceToGenderize: true | Først datasættet, derefter fortolkning af kaldenavnet uden krav om et egentligt fornavn | 1, hvis datasættet er nok; 2 i alt, hvis AI bruges |

### Prøv først en e-mailforespørgsel, der kun bruger datasættet

Eksempelinput garanterer ikke en bestemt forudsigelse. Sæt GENDERAPI_API_KEY i servermiljøet, og læg ikke nøglen i offentlig kode på klientsiden. V1 og V2 bruger den samme kontonøgle og den samme saldo. Kontrollér nøglen med /api/v2/usage, og bekræft, at meta.access.mode har værdien api_key.

Vælg et programmeringssprog. [Konfigurér din API-nøgle](https://www.genderapi.io/da/docs/v2/authentication#environment-setup), og kør derefter eksemplet på din server.

Hver forespørgsel om en forudsigelse er en ny operation, der koster kreditter, også når den gentages. Eksemplerne prøver ikke automatisk igen. Kontrollér opkrævningsstatus, før du sender en ny forespørgsel.

### Før du kører: adgang og fejlhåndtering

Kør eksemplerne på din server. Sæt GENDERAPI_API_KEY i procesmiljøet til din eksisterende API-nøgle. Bekræft, at meta.access.mode er api_key: En nøgle, der ikke genkendes, kan føre til IP-prøveadgangen.

JSON-svar med HTTP 4xx og 5xx bevarer fejlens body og returnerer en exitstatus, der ikke er nul. Kontrollér code, action og meta.usage.billing_status, før du prøver igen.

**cURL**

cURL 7.76+ i en POSIX-shell. Kør i din terminal. [Dokumentation for kørselsmiljø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+, indbygget fetch. Gem som example.mjs, og kør node example.mjs. [Dokumentation for kørselsmiljø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. Gem som example.py, og kør python3 example.py. [Dokumentation for kørselsmiljø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-udvidelsen. Gem som example.php, og kør php example.php. [Dokumentation for kørselsmiljø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-klienten. Gem som GenderApiExample.java, og kør java GenderApiExample.java. [Dokumentation for kørselsmiljø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**

Konsolapplikation med .NET 8+. Brug som Program.cs i et konsolprojekt, og kør derefter dotnet run. [Dokumentation for kørselsmiljø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. Gem som main.go, og kør go run main.go. [Dokumentation for kørselsmiljø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)
    }
}
```

- [Guide til fejl og nye forsøg →](https://www.genderapi.io/da/docs/v2/errors-and-retries)

### Håndtér resultater fra lister og gentagne forespørgsler

POST /api/v2/gender/batch accepterer op til 50 elementer med en API-nøgle og 10 med IP-prøveadgangen. Giv hvert element sine egne værdier for type, value og options. Hvis du vil bruge den almindelige AI-fallback, skal du angive fallback udtrykkeligt i hvert element. id skal være unikt inden for batchen; index starter ved nul inden for den sendte batch. Gem dine egne job- og kilderækkeidentifikatorer separat.

HTTP 200 betyder ikke, at alle elementer er gennemført. Håndtér resultaterne identified, unknown og error hver for sig; meta.summary.succeeded tæller både identified og unknown. Vurdér data.gender, source, confidence_kind, confidence, match og reason samlet. Behandl ikke en AI-score og en hyppighed i datasættet som ligeværdige.

Hvis meta.usage.billing_status har værdien confirmed, skal du kun gentage de driftsfejl, der tillader en ny forespørgsel. Hvis statussen er unconfirmed, eller svaret er gået tabt, skal du stoppe og kontrollere opkrævningen. Hvis du sender det samme element igen, også et gennemført unknown-resultat, oprettes en ny betalt operation; send aldrig hele listen igen i blinde.

[Kontrakt for batchforespørgsler](https://www.genderapi.io/da/docs/v2/batch) · [Svarfelter](https://www.genderapi.io/da/docs/v2/responses) · [AI-indstillinger](https://www.genderapi.io/da/docs/v2/ai-options) · [Vurdering af nøjagtighed og konfidens](https://www.genderapi.io/da/accuracy-methodology) · [Privatlivspolitik](https://www.genderapi.io/da/privacy-policy)

Tilføjelserne til Excel og Google Sheets og de andre færdige integrationer kan bruge deres egen forbindelse og deres eget resultatformat. Gå ikke ud fra, at deres output følger dette V2-JSON-skema; læs den aktuelle guide til den pågældende integration.

## Navn og køn fra e-mailadresser

### Kan man udtrække et navn fra en e-mailadresse?

GenderAPI kan udtrække et kandidatnavn fra delen før @ i understøttede personlige adresser og, når de er tilgængelige, returnere oplysninger om køn, land og konfidens. Kandidaten er en slutning og ikke et verificeret navn på den, der ejer postkassen.

### Giver alle adresser et navn?

Nej. Funktionsadresser, tilfældige identifikatorer og lokale dele uden et egentligt navn giver ikke altid et pålideligt signal. Kontrollér data.result_status, data.reason, data.confidence og data.confidence_kind i V2-svaret.

### Bliver e-mailforespørgsler gemt?

Ifølge den offentliggjorte politik gemmes e-mailforespørgsler ikke som genanvendelige forespørgselsposter. For separate tekniske logfiler og sikkerhedslogfiler gælder de perioder, der er angivet i privatlivspolitikken. Brug ikke følsomme personoplysninger i den offentlige demo.

### Kan jeg bruge funktionen i Excel og Google Sheets?

Ja. Kolonner med adresser kan behandles med tilføjelsen til Excel, tilføjelsen til Google Sheets eller importværktøjet til Excel- og CSV-filer. Disse integrationer har deres eget resultatformat, som er forskelligt fra V2-JSON.

### Hvilke felter returnerer API'et?

V2 returnerer data.name, data.gender, data.match og felterne for kilde og konfidens, og i meta også operationens id og forbruget af kreditter. Kandidatnavnet eller kønnet kan være null. Der findes ikke et felt til et verificeret efternavn.

### Hvornår bruges AI?

For en enkeltforespørgsel i V2 er den almindelige AI-fallback slået til som standard. I denne demo kan du bruge en standardforespørgsel eller forceToGenderize; off og always angiver du i API-forespørgslen. Den almindelige AI-fallback koster 1 kredit i alt, always 2. Med forceToGenderize opkræves 1 kredit, hvis datasættet giver et resultat, eller 2 i alt, hvis AI bruges; resultatet kan forblive unknown.

### Kan jeg prøve tjenesten gratis?

Konti indeholder 200 gratis kreditter om dagen, og den delte IP-prøveadgang giver 10 kreditter pr. offentlig IP-adresse inden for 24 timer. En manglende eller ukendt nøgle kan føre til IP-prøveadgangen; kontrollér feltet meta.access.mode i svaret. Der er tale om kreditter, ikke et antal forespørgsler.