Generate synthetic name data

curl --request POST \
  --url https://apix.spotzee.com/api/ext/generic/data/generate/name \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data count=10 \
  --data locale=en \
  --data gender=mixed \
  --data seed=12345 \
  --data type=full \
  --data includeMiddleName=false \
  --data includePrefixSuffix=false

import requests

url = "https://apix.spotzee.com/api/ext/generic/data/generate/name"

payload = {
    "count": "10",
    "locale": "en",
    "gender": "mixed",
    "seed": "12345",
    "type": "full",
    "includeMiddleName": "false",
    "includePrefixSuffix": "false"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {
    Authorization: 'Bearer <token>',
    'Content-Type': 'application/x-www-form-urlencoded'
  },
  body: new URLSearchParams({
    count: '10',
    locale: 'en',
    gender: 'mixed',
    seed: '12345',
    type: 'full',
    includeMiddleName: 'false',
    includePrefixSuffix: 'false'
  })
};

fetch('https://apix.spotzee.com/api/ext/generic/data/generate/name', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://apix.spotzee.com/api/ext/generic/data/generate/name"

	payload := strings.NewReader("count=10&locale=en&gender=mixed&seed=12345&type=full&includeMiddleName=false&includePrefixSuffix=false")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

{
  "status": "success",
  "data": {
    "names": [
      {
        "firstName": "Robert",
        "middleName": "James",
        "lastName": "Johnson",
        "fullName": "Robert James Johnson",
        "gender": "male",
        "prefix": "Mr.",
        "suffix": "Jr."
      }
    ],
    "generated": 1,
    "locale": "en",
    "seed": 12345
  },
  "performance": {
    "generationTime": 2,
    "itemsGenerated": 1,
    "locale": "en"
  }
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

POST

generic

data

generate

name

Generate synthetic name data

curl --request POST \
  --url https://apix.spotzee.com/api/ext/generic/data/generate/name \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data count=10 \
  --data locale=en \
  --data gender=mixed \
  --data seed=12345 \
  --data type=full \
  --data includeMiddleName=false \
  --data includePrefixSuffix=false

import requests

url = "https://apix.spotzee.com/api/ext/generic/data/generate/name"

payload = {
    "count": "10",
    "locale": "en",
    "gender": "mixed",
    "seed": "12345",
    "type": "full",
    "includeMiddleName": "false",
    "includePrefixSuffix": "false"
}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/x-www-form-urlencoded"
}

response = requests.post(url, data=payload, headers=headers)

print(response.text)

const options = {
  method: 'POST',
  headers: {
    Authorization: 'Bearer <token>',
    'Content-Type': 'application/x-www-form-urlencoded'
  },
  body: new URLSearchParams({
    count: '10',
    locale: 'en',
    gender: 'mixed',
    seed: '12345',
    type: 'full',
    includeMiddleName: 'false',
    includePrefixSuffix: 'false'
  })
};

fetch('https://apix.spotzee.com/api/ext/generic/data/generate/name', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://apix.spotzee.com/api/ext/generic/data/generate/name"

	payload := strings.NewReader("count=10&locale=en&gender=mixed&seed=12345&type=full&includeMiddleName=false&includePrefixSuffix=false")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/x-www-form-urlencoded")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}

{
  "status": "success",
  "data": {
    "names": [
      {
        "firstName": "Robert",
        "middleName": "James",
        "lastName": "Johnson",
        "fullName": "Robert James Johnson",
        "gender": "male",
        "prefix": "Mr.",
        "suffix": "Jr."
      }
    ],
    "generated": 1,
    "locale": "en",
    "seed": 12345
  },
  "performance": {
    "generationTime": 2,
    "itemsGenerated": 1,
    "locale": "en"
  }
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

{
  "status": "error",
  "error": "Invalid request parameters"
}

Authorizations

Authorization

string

header

required

Bearer token authentication. Use format: Bearer YOUR_API_KEY

Body

application/x-www-form-urlencoded

count

string

Number of names to generate (1-100). Passed as string but must be numeric.

Pattern: ^[1-9]\d?$|^100$

Example:

"10"

locale

string

Locale for generated data (e.g., en, es, fr, de, pt_BR, zh_CN)

Example:

"en"

gender

enum<string>

Gender for name generation

Available options:

male,

female,

mixed

Example:

"mixed"

seed

string

Seed for deterministic generation. Same seed produces same results.

Example:

"12345"

type

enum<string>

Type of name to generate.

Available options:

first,

middle,

last,

full,

prefix,

suffix

Example:

"full"

includeMiddleName

enum<string>

Include a generated middle name when type=full.

Available options:

true,

false

Example:

"false"

includePrefixSuffix

enum<string>

Include generated prefix and suffix fields when type=full.

Available options:

true,

false

Example:

"false"

Response

Successfully generated name data

status

enum<string>

required

Available options:

success

data

object

required

Hide child attributes

data.names

object[]

required

Hide child attributes

data.names.firstName

string

data.names.middleName

string

data.names.lastName

string

data.names.fullName

string

data.names.gender

enum<string>

Specific sex parameter used for generated name values, returned only when requested.

Available options:

male,

female

Example:

"male"

data.names.prefix

string

data.names.suffix

string

data.generated

number

required

data.locale

string

required

data.seed

number

performance

object

Hide child attributes

performance.generationTime

number

required

Generation time in milliseconds.

Example:

2

performance.itemsGenerated

number

required

Number of items generated.

Example:

10

performance.locale

string

required

Locale used for generation.

Example:

"en"

Overview

AI

Text

DNS

Email

SMS

Data

Generate synthetic name data

Authorizations

Body

Response