> ## Documentation Index
> Fetch the complete documentation index at: https://docs.lumiid.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Get Started with LumiID in 5 Minutes

> Create your LumiID account, generate API keys, and make your first identity verification call with cURL, Python, Node.js, or PHP.

This guide walks you through everything you need to go from zero to your first successful identity verification API call. You'll create a LumiID account, grab your Sandbox API key, send a NIN verification request, and read the response — all in about five minutes. No credit card required.

> [!NOTE]
>
> **Sandbox is free.** Sandbox requests use simulated data and never touch real government databases or consume wallet credits. Switch to Production only after your integration is validated.

**1. Create Your LumiID Account**

Before making any API calls, you need a LumiID account. Registration is free and takes about two minutes — you get instant access to the Sandbox environment.

1. Go to [lumiid.com](https://lumiid.com) and click **Get Started**.
2. Fill in your name, business email address, and a secure password. Check your inbox for the verification email and enter the OTP to activate your account.
3. Complete your **business profile** — enter your company name, industry, and intended use case. This helps LumiID configure the right verification products and compliance settings for your account.
4. You'll land in **Sandbox mode** by default. Stay here while you're developing and testing.

When you're ready to go live, switch to **Production** in the dashboard and fund your wallet. Sandbox requests are always free; production requests consume wallet credits.

**2. Get Your API Keys**

LumiID uses Secret Keys (Bearer Tokens) to authenticate every request. Your Secret Key must be kept server-side — never expose it in frontend code.

1. From the left sidebar, navigate to **Settings → API Keys**.
2. You'll see separate key pairs for Sandbox and Production. Copy your **Sandbox Secret Key** — you'll use this for the next step.
3. Store the key in an environment variable, not in your source code.

```bash .env theme={null}
# LumiID Credentials — never commit this file to version control
LUMIID_SECRET_KEY=your-sandbox-secret-key-here
LUMIID_ENV=sandbox   # change to "production" when going live
```

> [!WARNING]
>
> Your Secret Key grants full access to your LumiID account. Never expose it in frontend code, public repositories, or client-side JavaScript. If it's ever compromised, regenerate it immediately from **Settings → API Keys → Regenerate**.

**3. Make Your First API Call**

Let's verify a Nigerian NIN (National Identification Number). This is the most common first call developers make — it confirms that a NIN exists and returns the official identity record from the NIMC government database.

Send a `POST` request to `https://api.lumiid.com/v1/ng/nin-basic/` with the NIN in the request body. In Sandbox, use the test NIN `89184072280` — it returns realistic dummy data every time.

```bash cURL theme={null}
curl --request POST 'https://api.lumiid.com/v1/ng/nin-basic/' \
  --header 'Authorization: Bearer your-sandbox-secret-key' \
  --header 'Content-Type: application/json' \
  --data '{"nin": "89184072280"}'
```

```python Python theme={null}
import requests, os

secret_key = os.getenv("LUMIID_SECRET_KEY")

url = "https://api.lumiid.com/v1/ng/nin-basic/"

headers = {
    "Authorization": f"Bearer {secret_key}",
    "Content-Type": "application/json"
}

data = {"nin": "89184072280"}

response = requests.post(url, headers=headers, json=data)
print(response.json())
```

```javascript Node.js theme={null}
const axios = require('axios');

const secretKey = process.env.LUMIID_SECRET_KEY;

async function verifyNIN(nin) {
  const response = await axios.post(
    'https://api.lumiid.com/v1/ng/nin-basic/',
    { nin },
    {
      headers: {
        'Authorization': `Bearer ${secretKey}`,
        'Content-Type': 'application/json',
      },
    }
  );
  return response.data;
}

verifyNIN('89184072280').then(console.log).catch(console.error);
```

```php PHP theme={null}
$secretKey = getenv('LUMIID_SECRET_KEY');
$nin = '89184072280';

$ch = curl_init("https://api.lumiid.com/v1/ng/nin-basic/");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => [
        "Authorization: Bearer {$secretKey}",
        "Content-Type: application/json",
    ],
    CURLOPT_POST => true,
    CURLOPT_POSTFIELDS => json_encode(['nin' => $nin]),
]);

$response = json_decode(curl_exec($ch), true);
curl_close($ch);

var_dump($response);
```

| Parameter | Description |
| - | - |
| `Authorization` | Your Secret Key, prefixed with `Bearer ` (e.g. `Bearer your-secret-key`). Always send from your server — never from a browser or mobile app directly. |
| `nin` | The 11-digit NIN to verify. Use `89184072280` in Sandbox to get realistic test data. |

**4. Understand the Response**

Every LumiID response follows the same predictable JSON envelope. A successful NIN verification returns a `200 OK` with the verified identity record inside a `data` object.

```json 200 OK — NIN Verified theme={null}
{
  "success": true,
  "message": "Verification completed",
  "data": {
    "nin": "89184072280",
    "first_name": "Adaeze",
    "last_name": "Okonkwo",
    "middle_name": "Chioma",
    "date_of_birth": "1992-04-15",
    "gender": "Female",
    "phone_number": "080XXXXXXXX",
    "address": "14 Adeola Odeku, Victoria Island, Lagos",
    "state_of_origin": "Anambra",
    "photo": "data:image/jpeg;base64,/9j/4AAQ..."
  }
}
```

| Field | Type | Description |
| - | - | - |
| `data.nin` | string | The verified NIN, echoed back for confirmation. |
| `data.first_name` | string | Legal first name as registered with NIMC. |
| `data.last_name` | string | Legal last name as registered with NIMC. |
| `data.date_of_birth` | string | Date of birth in `YYYY-MM-DD` format. |
| `data.gender` | string | Gender as recorded in the NIMC database. |
| `data.photo` | string | Base64-encoded JPEG biometric photo from NIMC. Use this for Face Match verification. |

> [!TIP]
>
> Cross-reference `first_name`, `last_name`, and `date_of_birth` against what the user provided during signup. Then use the `photo` field as the reference image in a [Face Match](https://docs.lumiid.com/api-reference/face-match) call to confirm the person is who they claim to be.

## What's Next

You've made your first LumiID API call. Here's where to go from here:

> [card] [NIN Verification](https://docs.lumiid.com/api-reference/nin-verification)
>
> Full reference for all NIN endpoints, both Basic and Premium tiers, with all request parameters and response fields.

> [card] [BVN Verification](https://docs.lumiid.com/api-reference/bvn-verification)
>
> Verify Bank Verification Numbers against CBN data with a single API call.

> [card] [Biometric Checks](https://docs.lumiid.com/api-reference/liveness-detection)
>
> Add liveness detection and face matching to confirm a user is real, present, and matches their government ID photo.

> [card] [AML Screening](https://docs.lumiid.com/api-reference/aml-screening)
>
> Screen individuals and businesses against sanctions lists, PEP registers, and watchlists across 40+ sources.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.