A practical reference for building reliable integrations.

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/business/website-profile?domain=example.com"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/website-profile?domain=example.com', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/website-profile?domain=example.com', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/business/website-profile?domain=example.com');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/business/website-profile?domain=example.com', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/business/website-profile?domain=example.com
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  domain = example.com

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/business/domain-to-company?domain=example.com"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/domain-to-company?domain=example.com', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/domain-to-company?domain=example.com', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/business/domain-to-company?domain=example.com');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/business/domain-to-company?domain=example.com', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/business/domain-to-company?domain=example.com
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  domain = example.com

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/business/company-clean-name?name=Example+Travel+Limited"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/company-clean-name?name=Example+Travel+Limited', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/company-clean-name?name=Example+Travel+Limited', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/business/company-clean-name?name=Example+Travel+Limited');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/business/company-clean-name?name=Example+Travel+Limited', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/business/company-clean-name?name=Example+Travel+Limited
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  name = Example Travel Limited

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/business/email-domain-profile?domain=example.com"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/email-domain-profile?domain=example.com', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/email-domain-profile?domain=example.com', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/business/email-domain-profile?domain=example.com');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/business/email-domain-profile?domain=example.com', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/business/email-domain-profile?domain=example.com
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  domain = example.com

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/business/social-links?html=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/social-links?html=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/business/social-links?html=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/business/social-links?html=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/business/social-links?html=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/business/social-links?html=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  html = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/companies/search?name=example&q=example&address=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/search?name=example&q=example&address=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/search?name=example&q=example&address=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/companies/search?name=example&q=example&address=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/companies/search?name=example&q=example&address=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/companies/search?name=example&q=example&address=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  name = example
  q = example
  address = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/companies/profile?jurisdiction=GB&company_number=01234567"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/profile?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/profile?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/companies/profile?jurisdiction=GB&company_number=01234567');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/companies/profile?jurisdiction=GB&company_number=01234567', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/companies/profile?jurisdiction=GB&company_number=01234567
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  jurisdiction = GB
  company_number = 01234567

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/companies/officers?jurisdiction=GB&company_number=01234567"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/officers?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/officers?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/companies/officers?jurisdiction=GB&company_number=01234567');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/companies/officers?jurisdiction=GB&company_number=01234567', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/companies/officers?jurisdiction=GB&company_number=01234567
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  jurisdiction = GB
  company_number = 01234567

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/companies/psc?jurisdiction=GB&company_number=01234567"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/psc?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/psc?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/companies/psc?jurisdiction=GB&company_number=01234567');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/companies/psc?jurisdiction=GB&company_number=01234567', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/companies/psc?jurisdiction=GB&company_number=01234567
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  jurisdiction = GB
  company_number = 01234567

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/companies/filing-history?jurisdiction=GB&company_number=01234567"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/filing-history?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/filing-history?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/companies/filing-history?jurisdiction=GB&company_number=01234567');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/companies/filing-history?jurisdiction=GB&company_number=01234567', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/companies/filing-history?jurisdiction=GB&company_number=01234567
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  jurisdiction = GB
  company_number = 01234567

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/companies/charges?jurisdiction=GB&company_number=01234567"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/charges?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/charges?jurisdiction=GB&company_number=01234567', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/companies/charges?jurisdiction=GB&company_number=01234567');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/companies/charges?jurisdiction=GB&company_number=01234567', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/companies/charges?jurisdiction=GB&company_number=01234567
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  jurisdiction = GB
  company_number = 01234567

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/companies/sources"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/sources', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/companies/sources', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/companies/sources');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/companies/sources', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/companies/sources
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/trademarks/search?jurisdiction=EU&name=ACTOKI&q=ACTOKI"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/trademarks/search?jurisdiction=EU&name=ACTOKI&q=ACTOKI', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/trademarks/search?jurisdiction=EU&name=ACTOKI&q=ACTOKI', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/trademarks/search?jurisdiction=EU&name=ACTOKI&q=ACTOKI');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/trademarks/search?jurisdiction=EU&name=ACTOKI&q=ACTOKI', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/trademarks/search?jurisdiction=EU&name=ACTOKI&q=ACTOKI
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  jurisdiction = EU
  name = ACTOKI
  q = ACTOKI

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/trademarks/profile?jurisdiction=EU&application_number=018123456&serial_number=98765432"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/trademarks/profile?jurisdiction=EU&application_number=018123456&serial_number=98765432', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/trademarks/profile?jurisdiction=EU&application_number=018123456&serial_number=98765432', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/trademarks/profile?jurisdiction=EU&application_number=018123456&serial_number=98765432');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/trademarks/profile?jurisdiction=EU&application_number=018123456&serial_number=98765432', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/trademarks/profile?jurisdiction=EU&application_number=018123456&serial_number=98765432
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  jurisdiction = EU
  application_number = 018123456
  serial_number = 98765432

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/trademarks/sources"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/trademarks/sources', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/trademarks/sources', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/trademarks/sources');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/trademarks/sources', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/trademarks/sources
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/compliance/pii-scan?text=Contact+Jane+at+jane%40example.com."

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/pii-scan?text=Contact+Jane+at+jane%40example.com.', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/pii-scan?text=Contact+Jane+at+jane%40example.com.', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/compliance/pii-scan?text=Contact+Jane+at+jane%40example.com.');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/compliance/pii-scan?text=Contact+Jane+at+jane%40example.com.', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/compliance/pii-scan?text=Contact+Jane+at+jane%40example.com.
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = Contact Jane at jane@example.com.

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/compliance/redaction?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/redaction?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/redaction?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/compliance/redaction?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/compliance/redaction?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/compliance/redaction?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/compliance/retention-check?retention_days=365&created_at=now"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/retention-check?retention_days=365&created_at=now', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/retention-check?retention_days=365&created_at=now', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/compliance/retention-check?retention_days=365&created_at=now');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/compliance/retention-check?retention_days=365&created_at=now', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/compliance/retention-check?retention_days=365&created_at=now
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  retention_days = 365
  created_at = now

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/compliance/cookie-audit?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/cookie-audit?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/cookie-audit?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/compliance/cookie-audit?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/compliance/cookie-audit?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/compliance/cookie-audit?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/compliance/privacy-policy-check?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/privacy-policy-check?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/compliance/privacy-policy-check?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/compliance/privacy-policy-check?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/compliance/privacy-policy-check?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/compliance/privacy-policy-check?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/content/profanity?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/profanity?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/profanity?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/content/profanity?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/content/profanity?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/content/profanity?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/content/pii-detect?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/pii-detect?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/pii-detect?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/content/pii-detect?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/content/pii-detect?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/content/pii-detect?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/content/redact?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/redact?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/redact?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/content/redact?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/content/redact?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/content/redact?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/content/language-detect?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/language-detect?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/language-detect?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/content/language-detect?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/content/language-detect?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/content/language-detect?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/content/readability?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/readability?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/readability?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/content/readability?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/content/readability?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/content/readability?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/content/sentiment-basic?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/sentiment-basic?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/content/sentiment-basic?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/content/sentiment-basic?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/content/sentiment-basic?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/content/sentiment-basic?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data-quality/dedupe?text=example&items=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/dedupe?text=example&items=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/dedupe?text=example&items=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data-quality/dedupe?text=example&items=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data-quality/dedupe?text=example&items=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data-quality/dedupe?text=example&items=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example
  items = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data-quality/normalise?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/normalise?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/normalise?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data-quality/normalise?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data-quality/normalise?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data-quality/normalise?text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data-quality/fuzzy-match?a=example&b=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/fuzzy-match?a=example&b=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/fuzzy-match?a=example&b=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data-quality/fuzzy-match?a=example&b=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data-quality/fuzzy-match?a=example&b=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data-quality/fuzzy-match?a=example&b=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  a = example
  b = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data-quality/name-split?name=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/name-split?name=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/name-split?name=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data-quality/name-split?name=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data-quality/name-split?name=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data-quality/name-split?name=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  name = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data-quality/company-name-clean?name=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/company-name-clean?name=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data-quality/company-name-clean?name=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data-quality/company-name-clean?name=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data-quality/company-name-clean?name=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data-quality/company-name-clean?name=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  name = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/spreadsheet/profile?csv=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/profile?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/profile?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/spreadsheet/profile?csv=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/spreadsheet/profile?csv=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/spreadsheet/profile?csv=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  csv = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/spreadsheet/clean?csv=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/clean?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/clean?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/spreadsheet/clean?csv=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/spreadsheet/clean?csv=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/spreadsheet/clean?csv=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  csv = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/spreadsheet/detect-columns?csv=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/detect-columns?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/detect-columns?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/spreadsheet/detect-columns?csv=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/spreadsheet/detect-columns?csv=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/spreadsheet/detect-columns?csv=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  csv = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/spreadsheet/validate-emails?csv=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/validate-emails?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/validate-emails?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/spreadsheet/validate-emails?csv=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/spreadsheet/validate-emails?csv=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/spreadsheet/validate-emails?csv=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  csv = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/spreadsheet/dedupe-rows?csv=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/dedupe-rows?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spreadsheet/dedupe-rows?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/spreadsheet/dedupe-rows?csv=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/spreadsheet/dedupe-rows?csv=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/spreadsheet/dedupe-rows?csv=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  csv = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/date/business-days?end=%2B30+days&start=today"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/business-days?end=%2B30+days&start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/business-days?end=%2B30+days&start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/date/business-days?end=%2B30+days&start=today');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/date/business-days?end=%2B30+days&start=today', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/date/business-days?end=%2B30+days&start=today
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  end = +30 days
  start = today

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/date/add-business-days?start=today&days=5"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/add-business-days?start=today&days=5', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/add-business-days?start=today&days=5', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/date/add-business-days?start=today&days=5');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/date/add-business-days?start=today&days=5', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/date/add-business-days?start=today&days=5
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  start = today
  days = 5

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/date/working-days-between?end=%2B30+days&start=today"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/working-days-between?end=%2B30+days&start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/working-days-between?end=%2B30+days&start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/date/working-days-between?end=%2B30+days&start=today');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/date/working-days-between?end=%2B30+days&start=today', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/date/working-days-between?end=%2B30+days&start=today
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  end = +30 days
  start = today

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/date/age?dob=2000-01-01"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/age?dob=2000-01-01', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/age?dob=2000-01-01', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/date/age?dob=2000-01-01');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/date/age?dob=2000-01-01', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/date/age?dob=2000-01-01
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  dob = 2000-01-01

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/date/countdown?end=%2B30+days&start=today"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/countdown?end=%2B30+days&start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/countdown?end=%2B30+days&start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/date/countdown?end=%2B30+days&start=today');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/date/countdown?end=%2B30+days&start=today', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/date/countdown?end=%2B30+days&start=today
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  end = +30 days
  start = today

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/date/payday?start=today"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/payday?start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/date/payday?start=today', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/date/payday?start=today');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/date/payday?start=today', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/date/payday?start=today
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  start = today

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --request POST \
  --header "Authorization: Bearer $API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "type": "domain",
    "target": "example"
}' \
  "https://actoki.com/v1/blacklist/check"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/blacklist/check', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "type": "domain",
    "target": "example"
}),
});

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/blacklist/check', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "type": "domain",
    "target": "example"
}),
});

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/blacklist/check');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => json_encode(array (
  'type' => 'domain',
  'target' => 'example',
), JSON_THROW_ON_ERROR),
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer ' . $apiKey,
    'Content-Type: application/json',
  ],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

payload = {
    "type": "domain",
    "target": "example"
}
headers['Content-Type'] = 'application/json'
response = requests.post('https://actoki.com/v1/blacklist/check', headers=headers, json=payload, timeout=20)

response.raise_for_status()
print(response.json())

Method: POST
URL: https://actoki.com/v1/blacklist/check
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY
Content-Type: application/json
JSON body:
{
    "type": "domain",
    "target": "example"
}

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/blacklist/monitors?id=example&type=domain&target=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/blacklist/monitors?id=example&type=domain&target=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/blacklist/monitors?id=example&type=domain&target=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/blacklist/monitors?id=example&type=domain&target=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/blacklist/monitors?id=example&type=domain&target=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/blacklist/monitors?id=example&type=domain&target=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  id = example
  type = domain
  target = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --request POST \
  --header "Authorization: Bearer $API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "smtp": false,
    "first_name": "example",
    "last_name": "example"
}' \
  "https://actoki.com/v1/email-finder/find"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/email-finder/find', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "smtp": false,
    "first_name": "example",
    "last_name": "example"
}),
});

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/email-finder/find', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "smtp": false,
    "first_name": "example",
    "last_name": "example"
}),
});

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/email-finder/find');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => json_encode(array (
  'smtp' => false,
  'first_name' => 'example',
  'last_name' => 'example',
), JSON_THROW_ON_ERROR),
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer ' . $apiKey,
    'Content-Type: application/json',
  ],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

payload = {
    "smtp": False,
    "first_name": "example",
    "last_name": "example"
}
headers['Content-Type'] = 'application/json'
response = requests.post('https://actoki.com/v1/email-finder/find', headers=headers, json=payload, timeout=20)

response.raise_for_status()
print(response.json())

Method: POST
URL: https://actoki.com/v1/email-finder/find
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY
Content-Type: application/json
JSON body:
{
    "smtp": false,
    "first_name": "example",
    "last_name": "example"
}

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --request POST \
  --header "Authorization: Bearer $API_KEY" \
  --header "Content-Type: application/json" \
  --data '{
    "people": "example"
}' \
  "https://actoki.com/v1/email-finder/batch"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/email-finder/batch', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "people": "example"
}),
});

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/email-finder/batch', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${apiKey}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    "people": "example"
}),
});

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/email-finder/batch');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_POST => true,
  CURLOPT_POSTFIELDS => json_encode(array (
  'people' => 'example',
), JSON_THROW_ON_ERROR),
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer ' . $apiKey,
    'Content-Type: application/json',
  ],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

payload = {
    "people": "example"
}
headers['Content-Type'] = 'application/json'
response = requests.post('https://actoki.com/v1/email-finder/batch', headers=headers, json=payload, timeout=20)

response.raise_for_status()
print(response.json())

Method: POST
URL: https://actoki.com/v1/email-finder/batch
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY
Content-Type: application/json
JSON body:
{
    "people": "example"
}

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/inbox-placement/tests?label=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/inbox-placement/tests?label=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/inbox-placement/tests?label=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/inbox-placement/tests?label=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/inbox-placement/tests?label=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/inbox-placement/tests?label=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  label = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/inbox-placement/status?id=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/inbox-placement/status?id=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/inbox-placement/status?id=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/inbox-placement/status?id=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/inbox-placement/status?id=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/inbox-placement/status?id=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  id = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/spam-test/tests?label=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spam-test/tests?label=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spam-test/tests?label=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/spam-test/tests?label=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/spam-test/tests?label=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/spam-test/tests?label=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  label = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/spam-test/status?id=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spam-test/status?id=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/spam-test/status?id=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/spam-test/status?id=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/spam-test/status?id=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/spam-test/status?id=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  id = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/design/palette/random?count=5&style=bright"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/palette/random?count=5&style=bright', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/palette/random?count=5&style=bright', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/design/palette/random?count=5&style=bright');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/design/palette/random?count=5&style=bright', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/design/palette/random?count=5&style=bright
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  count = 5
  style = bright

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/design/palette/from-colour?colour=%233B82F6&count=5&style=bright"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/palette/from-colour?colour=%233B82F6&count=5&style=bright', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/palette/from-colour?colour=%233B82F6&count=5&style=bright', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/design/palette/from-colour?colour=%233B82F6&count=5&style=bright');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/design/palette/from-colour?colour=%233B82F6&count=5&style=bright', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/design/palette/from-colour?colour=%233B82F6&count=5&style=bright
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  colour = #3B82F6
  count = 5
  style = bright

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/design/colour/convert?colour=%233B82F6"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/colour/convert?colour=%233B82F6', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/colour/convert?colour=%233B82F6', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/design/colour/convert?colour=%233B82F6');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/design/colour/convert?colour=%233B82F6', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/design/colour/convert?colour=%233B82F6
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  colour = #3B82F6

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/design/colour/contrast?foreground=%23111827&background=%23fff"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/colour/contrast?foreground=%23111827&background=%23fff', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/colour/contrast?foreground=%23111827&background=%23fff', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/design/colour/contrast?foreground=%23111827&background=%23fff');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/design/colour/contrast?foreground=%23111827&background=%23fff', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/design/colour/contrast?foreground=%23111827&background=%23fff
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  foreground = #111827
  background = #fff

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/design/gradient?from=%233B82F6&to=%2322C55E&direction=90deg"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/gradient?from=%233B82F6&to=%2322C55E&direction=90deg', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/design/gradient?from=%233B82F6&to=%2322C55E&direction=90deg', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/design/gradient?from=%233B82F6&to=%2322C55E&direction=90deg');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/design/gradient?from=%233B82F6&to=%2322C55E&direction=90deg', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/design/gradient?from=%233B82F6&to=%2322C55E&direction=90deg
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  from = #3B82F6
  to = #22C55E
  direction = 90deg

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data/csv-to-json?csv=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/csv-to-json?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/csv-to-json?csv=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data/csv-to-json?csv=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data/csv-to-json?csv=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data/csv-to-json?csv=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  csv = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data/json-to-csv?json=%5B%5D"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/json-to-csv?json=%5B%5D', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/json-to-csv?json=%5B%5D', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data/json-to-csv?json=%5B%5D');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data/json-to-csv?json=%5B%5D', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data/json-to-csv?json=%5B%5D
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  json = []

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data/xml-to-json?xml=%3Croot%2F%3E"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/xml-to-json?xml=%3Croot%2F%3E', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/xml-to-json?xml=%3Croot%2F%3E', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data/xml-to-json?xml=%3Croot%2F%3E');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data/xml-to-json?xml=%3Croot%2F%3E', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data/xml-to-json?xml=%3Croot%2F%3E
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  xml = <root/>

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/data/flatten-json?json=%7B%7D"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/flatten-json?json=%7B%7D', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/data/flatten-json?json=%7B%7D', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/data/flatten-json?json=%7B%7D');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/data/flatten-json?json=%7B%7D', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/data/flatten-json?json=%7B%7D
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  json = {}

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/dev/uuid?count=1"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/dev/uuid?count=1', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/dev/uuid?count=1', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/dev/uuid?count=1');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/dev/uuid?count=1', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/dev/uuid?count=1
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  count = 1

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/dev/hash?algorithm=sha256&text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/dev/hash?algorithm=sha256&text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/dev/hash?algorithm=sha256&text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/dev/hash?algorithm=sha256&text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/dev/hash?algorithm=sha256&text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())

Method: GET
URL: https://actoki.com/v1/dev/hash?algorithm=sha256&text=example
Header name: Authorization
Header value: Bearer YOUR_ACTOKI_API_KEY

Query parameters:
  algorithm = sha256
  text = example

API_KEY="YOUR_ACTOKI_API_KEY"

curl --fail-with-body --silent --show-error \
  --header "Authorization: Bearer $API_KEY" \
  "https://actoki.com/v1/dev/base64/encode?text=example"

// Public browser code must call your own backend; never expose a permanent server key.
const apiKey = "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/dev/base64/encode?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

// Node.js 18+. Store the key in ACTOKI_API_KEY.
const apiKey = process.env.ACTOKI_API_KEY ?? "YOUR_ACTOKI_API_KEY";
const response = await fetch('https://actoki.com/v1/dev/base64/encode?text=example', { headers: { Authorization: `Bearer ${apiKey}` } });

if (!response.ok) throw new Error(`Actoki API error ${response.status}`);
console.log(await response.json());

<?php
$apiKey = getenv('ACTOKI_API_KEY') ?: 'YOUR_ACTOKI_API_KEY';

$ch = curl_init('https://actoki.com/v1/dev/base64/encode?text=example');
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
  CURLOPT_HTTPHEADER => ['Authorization: Bearer ' . $apiKey],
]);
$body = curl_exec($ch);
$status = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);

if ($status >= 400) throw new RuntimeException("Actoki API error $status: $body");
print_r(json_decode((string)$body, true, 512, JSON_THROW_ON_ERROR));

# pip install requests
import os
import requests

api_key = os.environ.get('ACTOKI_API_KEY', "YOUR_ACTOKI_API_KEY")
headers = {'Authorization': f'Bearer {api_key}'}

response = requests.get('https://actoki.com/v1/dev/base64/encode?text=example', headers=headers, timeout=20)

response.raise_for_status()
print(response.json())