# Get list of parsing models
Source: https://docs.deepxl.ai/api-reference/document-parsing/get-list-of-parsing-models

/openapi.json get /v1/parsing-models
Retrieve a list of available document parsing models with their capabilities and supported file types.



# Get Parse History
Source: https://docs.deepxl.ai/api-reference/document-parsing/get-parse-history

/openapi.json get /v1/parse
Get the document parse history for the organization. Supports sorting, pagination, and tag filtering.



# Get parsed document
Source: https://docs.deepxl.ai/api-reference/document-parsing/get-parsed-document

/openapi.json get /v1/parse/{parseId}
Retrieve the results of a previously parsed document by its ID, including all associated tags and files.



# Parse Document
Source: https://docs.deepxl.ai/api-reference/document-parsing/parse-document

/openapi.json post /v1/parse
Extract visible user information from a document or issued ID.

**Available Models:**
- `light` - Parsing light model. Data extraction is aimed at Driver License, State ID, Residency Permit, Social Security Card, Military ID
- `performance` - Parsing performance model. Data extraction is aimed at Bank statements, US pay stubs

**Tags Parameter:**
Pass optional metadata as a JSON object to organize and filter your parsing results.

**Recommended tag fields:**
| Field | Description | Example |
|-------|-------------|---------|
| `customerId` | Your customer's unique identifier | `"9999"` |
| `customerName` | Customer or account name | `"Acme Corp"` |
| `documentId` | Your internal document reference | `"DOC-2024-001"` |
| `companyName` | Company name | `"DeepXL"` |
| `companyId` | Company identifier | `"COMP-001"` |

**Example tags value:** `{"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-2024-001","companyName":"DeepXL","companyId":"COMP-001"}`

You can filter results by tags using the GET endpoint: `?tagFilter=customerId=9999`



# Retrieve a file
Source: https://docs.deepxl.ai/api-reference/file-retrieval/retrieve-a-file

/openapi.json get /v1/files/{fileName}
Retrieve a file from cloud storage. Files are associated with analysis results (fraud detection, parsing, verification) and include original uploads and generated heatmaps.



# Analyze a file for fraud detection
Source: https://docs.deepxl.ai/api-reference/fraud-detection/analyze-a-file-for-fraud-detection

/openapi.json post /v1/detection
Analyze a file for fraud detection using the specified model.

**Available Models:**
- `document` - For PDFs and document images (bank statements, invoices, IDs)
- `object` - For general images and AI-generated content detection

**Likelihood:** Returned as 0-100% where higher values indicate higher probability of manipulation/fraud.

**Tags Parameter:**
Pass optional metadata as a JSON object to organize and filter your analysis results.

**Recommended tag fields:**
| Field | Description | Example |
|-------|-------------|---------|
| `customerId` | Your customer's unique identifier | `"9999"` |
| `customerName` | Customer or account name | `"Acme Corp"` |
| `documentId` | Your internal document reference | `"DOC-2024-001"` |
| `companyName` | Company name | `"DeepXL"` |
| `companyId` | Company identifier | `"COMP-001"` |

**Example tags value:** `{"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-2024-001","companyName":"DeepXL","companyId":"COMP-001"}`

You can filter results by tags using the GET endpoint: `?tagFilter=customerId=9999`



# Get available fraud detection models
Source: https://docs.deepxl.ai/api-reference/fraud-detection/get-available-fraud-detection-models

/openapi.json get /v1/detection-models
Get a list of available fraud detection models with their capabilities and supported file types.



# Get cross-document evidence links for a detection
Source: https://docs.deepxl.ai/api-reference/fraud-detection/get-cross-document-evidence-links-for-a-detection

/openapi.json get /v1/detection/{detectionId}/evidence-links
Get inbound and outbound stored cross-document evidence links for a fraud detection record.



# Get fraud detection by ID
Source: https://docs.deepxl.ai/api-reference/fraud-detection/get-fraud-detection-by-id

/openapi.json get /v1/detection/{detectionId}
Get a specific fraud detection record by its ID, including all associated tags and files.



# Get fraud detection history
Source: https://docs.deepxl.ai/api-reference/fraud-detection/get-fraud-detection-history

/openapi.json get /v1/detection
Get a paginated list of fraud detection records for the organization. Supports sorting, pagination, and tag filtering.



# Get Verification
Source: https://docs.deepxl.ai/api-reference/id-verification/get-verification

/openapi.json get /v1/verification/{verificationId}
Get details of a specific verification by its ID, including all associated tags and files.



# List verification history
Source: https://docs.deepxl.ai/api-reference/id-verification/list-verification-history

/openapi.json get /v1/verification
List verification history for the organization. Supports sorting, pagination, and tag filtering.



# Verify user with their ID and selfie
Source: https://docs.deepxl.ai/api-reference/id-verification/verify-user-with-their-id-and-selfie

/openapi.json post /v1/verification
Verify a user's identity by uploading an ID document and a selfie.

The system compares the face in the ID with the selfie and performs liveness checks to ensure the person is real.

**Required Files:**
- `idFile` - ID document image or PDF (driver license, passport, etc.)
- `selfieFile` - Selfie still image **or** selfie video (e.g. mp4, mov, webm), same field name for both

**Tags Parameter:**
Pass optional metadata as a JSON object to organize and filter your verification results.

**Recommended tag fields:**
| Field | Description | Example |
|-------|-------------|---------|
| `customerId` | Your customer's unique identifier | `"9999"` |
| `customerName` | Customer or account name | `"Acme Corp"` |
| `documentId` | Your internal document reference | `"DOC-2024-001"` |
| `companyName` | Company name | `"DeepXL"` |
| `companyId` | Company identifier | `"COMP-001"` |

**Example tags value:** `{"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-2024-001","companyName":"DeepXL","companyId":"COMP-001"}`

You can filter results by tags using the GET endpoint: `?tagFilter=customerId=9999`



# Authentication
Source: https://docs.deepxl.ai/en/authentication

Authenticate your API requests with an API key

All DeepXL API endpoints require authentication using an **API key**.

## API Key Authentication

Pass your API key in the `x-api-key` header:

```bash theme={null}
curl https://api.deepxl.ai/v1/detection \
  -H "x-api-key: YOUR_API_KEY"
```

### Managing API Keys

Manage API keys from the DeepXL Console. These management endpoints are console-only and are not part of the public API.

<Note>
  Use the Console dashboard for API key creation, rename, and deletion. Public API keys cannot be used to manage other API keys.
</Note>

## Error Responses

| Status             | Description                                    |
| ------------------ | ---------------------------------------------- |
| `401 Unauthorized` | Missing or invalid API key                     |
| `403 Forbidden`    | Valid credentials but insufficient permissions |

```json theme={null}
{
  "statusCode": 401,
  "error": "Unauthorized",
  "message": "Unauthorized"
}
```


# AI Assistants (Claude & ChatGPT)
Source: https://docs.deepxl.ai/en/guides/ai-assistants

Connect DeepXL to Claude or ChatGPT and check documents for fraud in chat

DeepXL runs as a remote [MCP](https://modelcontextprotocol.io) connector, so you can add it directly to **Claude** (Claude Cowork and custom connectors) and **ChatGPT** (Work). Once connected, drop a document into the conversation and ask whether it's fraudulent — the assistant calls DeepXL and returns a real forensic verdict.

The connector URL is:

```
https://mcp.deepxl.ai/mcp
```

## Connect it to Claude

<Steps>
  <Step title="Open connector settings">
    In Claude, go to **Settings → Connectors** and choose **Add custom connector**.
  </Step>

  <Step title="Add the DeepXL server">
    Give it a name (for example, `DeepXL Fraud`) and set the **Remote MCP server URL** to `https://mcp.deepxl.ai/mcp`.
  </Step>

  <Step title="Sign in with your DeepXL account">
    Choose **Individual sign-in**. A browser window opens at `clerk.deepxl.ai` — sign into your DeepXL account. There is no API key to paste.
  </Step>

  <Step title="Select your organization">
    When prompted, grant access and **select the organization** you want to use. Analyses run under, and are billed to, that organization.
  </Step>

  <Step title="Use it in a chat">
    The DeepXL tools now appear in Claude. Attach a document (or paste a URL) and ask something like *"Is this document fraudulent?"*
  </Step>
</Steps>

<Note>
  Custom connectors are available on Claude's Team, Enterprise, and paid individual plans. If you don't see **Add custom connector**, that's your Claude plan, not DeepXL.
</Note>

## Connect it to ChatGPT

In ChatGPT Work, add a custom connector / MCP server pointing to `https://mcp.deepxl.ai/mcp` and complete the same **sign-in** flow. The available tools and behavior are identical to Claude.

## What you can do

The connector exposes three tools:

| Tool                 | What it does                                                                                                              |
| -------------------- | ------------------------------------------------------------------------------------------------------------------------- |
| `analyze_document`   | Analyze a document or image for fraud — pass a file (up to 10MB) or a `source_url` (up to 50MB). Returns a fraud verdict. |
| `list_models`        | List the available detection models and the file types each accepts.                                                      |
| `get_evidence_links` | Fetch the evidence behind a prior detection (why it was flagged and related detections), by `detectionId`.                |

You don't call these directly — just ask the assistant in plain language (e.g. *"analyze this bank statement for tampering"*) and it picks the right tool.

## Credits & billing

Every analysis is attributed to the **organization you signed in with** and consumes **one credit** from that organization's balance — the same credits used across the DeepXL Console and API.

<Warning>
  If your organization is out of credits, `analyze_document` returns **`402 Payment Required`** and the assistant will tell you you're out of credits. Add credits from the [DeepXL Console](https://console.deepxl.ai) or contact us, then try again.
</Warning>

## Troubleshooting

| Symptom                                            | Cause & fix                                                                                                       |
| -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| "Select your organization / grant `user:org:read`" | You signed in without choosing an organization. Reconnect and select one.                                         |
| `402 Payment Required`                             | The organization has no remaining credits. Top up in the Console.                                                 |
| Tools don't appear                                 | The connector didn't finish connecting — remove it and re-add `https://mcp.deepxl.ai/mcp`, then complete sign-in. |

For programmatic access without an assistant, use the [DeepXL API](/en/authentication) directly with an API key.


# Document Parsing
Source: https://docs.deepxl.ai/en/guides/document-parsing

Extract and parse structured data from IDs and documents

The Parsing Model extracts and parses structured data from IDs and documents — names, dates, addresses, amounts, and more.

## Available Models

| Model         | Use Case                                                                                                                                             | Supported File Types      |
| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- |
| `light`       | Parsing light model. Data extraction is aimed at Driver License, State ID, Residency Permit, Social Security Card, Military ID                       | jpg, jpeg, png, webp, pdf |
| `performance` | Parsing performance model. Data extraction is aimed at bank statements, US pay stubs, and common government-issued IDs (for example driver licenses) | jpg, jpeg, png, webp, pdf |

Retrieve the full list of models programmatically:

```bash theme={null}
curl https://api.deepxl.ai/v1/parsing-models \
  -H "x-api-key: YOUR_API_KEY"
```

## Parsing a Document

Submit a file for parsing via `POST /v1/parse`:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/parse \
  -H "x-api-key: YOUR_API_KEY" \
  -F "model=light" \
  -F "file=@drivers_license.jpg" \
  -F 'tags={"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-001","companyName":"DeepXL","companyId":"COMP-001"}'
```

### Parameters

| Parameter | Type   | Required | Description                                                                                                   |
| --------- | ------ | -------- | ------------------------------------------------------------------------------------------------------------- |
| `model`   | string | Yes      | `light` or `performance`                                                                                      |
| `file`    | file   | Yes      | The document to parse (max 50MB)                                                                              |
| `tags`    | string | No       | JSON object with metadata key-value pairs                                                                     |
| `country` | string | No       | Optional country hint. Supported values: `us`, `mx`, `br`. Missing, empty, or invalid values default to `us`. |

### Country Hint Behavior

Use the optional `country` parameter when you want to steer parsing toward a specific supported market.

* Supported values: `us`, `mx`, `br`
* Matching is case-insensitive
* Leading and trailing whitespace is ignored
* Missing, empty, or invalid values fall back to `us`

The request value is treated as a **routing hint**. It is normalized before the request is forwarded downstream, and the normalized value is returned as `country` in the parse response metadata.

Example:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/parse \
  -H "x-api-key: YOUR_API_KEY" \
  -F "model=performance" \
  -F "file=@bank_statement.pdf" \
  -F "country=br" \
  -F 'tags={"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-2024-042","companyName":"DeepXL","companyId":"COMP-001"}'
```

## Response Structure

```json theme={null}
{
  "result": {
    "parseId": 123,
    "mediaType": "image",
    "fileType": "jpeg",
    "fileName": "drivers_license.jpg",
    "fileSize": 231433,
    "timestamp": 1770984134,
    "timestampISO": "2026-02-13T13:02:14.833162",
    "model": "light",
    "modelVersion": "1.2.0",
    "documentType": "idDocument",
    "parsedData": {
      "firstName": "JOHN",
      "lastName": "DOE",
      "dateOfBirth": "1990-05-15",
      "licenseNumber": "D1234567",
      "expirationDate": "2028-05-15",
      "address": "123 MAIN ST ANYTOWN, CA 90210"
    },
    "tags": [
      { "name": "customerId", "value": "9999" },
      { "name": "customerName", "value": "Acme Corp" },
      { "name": "documentId", "value": "DOC-001" },
      { "name": "companyName", "value": "DeepXL" },
      { "name": "companyId", "value": "COMP-001" }
    ],
    "files": [
      {
        "category": "original_file",
        "fileName": "drivers_license.jpg",
        "fileSize": 231433,
        "contentType": "image/jpeg",
        "timestamp": 1770984134,
        "timestampISO": "2026-02-13T13:02:14.833162",
        "url": "https://api.deepxl.ai/v1/files/parse_123_drivers_license.jpg"
      }
    ]
  }
}
```

### Field Reference

| Field          | Type      | Description                                                                    |
| -------------- | --------- | ------------------------------------------------------------------------------ |
| `parseId`      | integer   | Unique identifier for the parse record                                         |
| `mediaType`    | string    | Media type category (`image` or `document`)                                    |
| `fileType`     | string    | File extension (`jpeg`, `png`, `pdf`, `webp`)                                  |
| `fileName`     | string    | Original uploaded file name                                                    |
| `fileSize`     | integer   | File size in bytes                                                             |
| `timestamp`    | integer   | Unix timestamp of the analysis                                                 |
| `timestampISO` | string    | ISO 8601 timestamp of the analysis                                             |
| `model`        | string    | Model used (`light` or `performance`)                                          |
| `modelVersion` | string    | Version of the model used for analysis                                         |
| `documentType` | string    | Identified document type (e.g. `idDocument`, `bankStatement.us`, `payStub.us`) |
| `parsedData`   | object    | Extracted key-value pairs (fields vary by document type)                       |
| `tags`         | object\[] | Metadata tags attached to this parse                                           |
| `files`        | object\[] | Associated files (original upload)                                             |

## Understanding Results

### Document Type

The `documentType` field identifies the parsed document type (for example `idDocument`, `bankStatement.us`, or `payStub.us`).

### Parsed Data

The `parsedData` object contains the extracted key-value pairs. The fields depend on the document type.

**ID Documents (light model):**

| Field            | Description                           |
| ---------------- | ------------------------------------- |
| `firstName`      | First name                            |
| `lastName`       | Last name                             |
| `dateOfBirth`    | Date of birth (YYYY-MM-DD)            |
| `licenseNumber`  | License or document number            |
| `expirationDate` | Document expiration date (YYYY-MM-DD) |
| `address`        | Full address                          |

**`performance` model document types:**

The extracted fields vary by document type. The current set is `idDocument`, `bankStatement.us`, and `payStub.us`.

## Tags and Filtering

Attach metadata to organize your parsing results:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/parse \
  -H "x-api-key: YOUR_API_KEY" \
  -F "model=performance" \
  -F "file=@bank_statement.pdf" \
  -F 'tags={"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-2024-042","companyName":"DeepXL","companyId":"COMP-001"}'
```

Filter your parse history:

```bash theme={null}
curl "https://api.deepxl.ai/v1/parse?tagFilter=customerId=9999" \
  -H "x-api-key: YOUR_API_KEY"
```

## Browsing History

Retrieve paginated parsing results:

```bash theme={null}
curl "https://api.deepxl.ai/v1/parse?limit=25&offset=0&sortBy=parseId&direction=desc" \
  -H "x-api-key: YOUR_API_KEY"
```

### Sort Options

`parseId`, `mediaType`, `fileType`, `fileName`, `fileSize`, `confidence`, `documentType`, `timestamp`


# File Retrieval
Source: https://docs.deepxl.ai/en/guides/file-retrieval

Retrieve original uploads and generated files from analysis results

Every analysis (fraud detection, parsing, verification) stores associated files in cloud storage. Use the File Retrieval API to download original uploads and generated assets like heatmaps.

## Retrieving a File

Each analysis response includes a `files` array with download URLs. Use the file name from the URL to retrieve the file:

```bash theme={null}
curl https://api.deepxl.ai/v1/files/fd_42_bank_statement.pdf \
  -H "x-api-key: YOUR_API_KEY" \
  --output bank_statement.pdf
```

The endpoint returns the file as a binary stream with the appropriate `Content-Type` header.

## File Categories

Files in analysis responses are categorized by their role:

| Category        | Service                  | Description                                          |
| --------------- | ------------------------ | ---------------------------------------------------- |
| `original_file` | Fraud Detection, Parsing | The file you originally uploaded                     |
| `heatmap`       | Fraud Detection          | Generated heatmap highlighting detected manipulation |
| `id`            | Verification             | The ID document image                                |
| `face`          | Verification             | The selfie image                                     |

## Finding File URLs

File URLs are included in every analysis response under the `files` array:

```json theme={null}
{
  "files": [
    {
      "category": "original_file",
      "fileName": "bank_statement.pdf",
      "fileSize": 245678,
      "contentType": "application/pdf",
      "timestamp": 1735689600000,
      "timestampISO": "2025-01-01T00:00:00.000Z",
      "url": "https://api.deepxl.ai/v1/files/fd_42_bank_statement.pdf"
    },
    {
      "category": "heatmap",
      "fileName": "fd_42_heatmap_1.png",
      "fileSize": 45678,
      "contentType": "image/png",
      "timestamp": 1735689601000,
      "timestampISO": "2025-01-01T00:00:01.000Z",
      "url": "https://api.deepxl.ai/v1/files/fd_42_heatmap_1.png"
    }
  ]
}
```

## Access Control

Files are scoped to your organization. You can only retrieve files associated with your own analyses. Attempting to access another organization's files returns a `404`.


# Fraud Detection
Source: https://docs.deepxl.ai/en/guides/fraud-detection

Detect document manipulation and AI-generated content

The Fraud Detection API uses forensic AI to detect manipulated, altered, and AI-generated documents and images in real time.

## Available Models

| Model      | Use Case                                                                                                  | Supported File Types      |
| ---------- | --------------------------------------------------------------------------------------------------------- | ------------------------- |
| `document` | Detects AI-generated or altered documents and IDs (bank statements, invoices, passports, driver licenses) | jpg, jpeg, png, webp, pdf |
| `object`   | Detects AI-generated or manipulated images (photos, claim evidence, receipts)                             | jpg, jpeg, png, webp      |

Retrieve the full list of models programmatically:

```bash theme={null}
curl https://api.deepxl.ai/v1/detection-models \
  -H "x-api-key: YOUR_API_KEY"
```

## Supported Document Types

The `document` model classifies uploaded files into 71 types via the `DOCUMENT_CLASSIFIER` check, organized into 8 categories:

### Identity (11 types)

| Type                      | Description                     |
| ------------------------- | ------------------------------- |
| `driver_license`          | Driver license                  |
| `national_id`             | National identification card    |
| `municipal_id`            | Municipal / local government ID |
| `passport`                | Passport book                   |
| `passport_card`           | Passport card (wallet-sized)    |
| `residence_card`          | Residence permit card           |
| `work_authorization`      | Work authorization / permit     |
| `military_id`             | Military identification         |
| `professional_id`         | Professional license / ID       |
| `voter_registration_card` | Voter registration card         |
| `social_security_card`    | Social Security card            |

### Financial (19 types)

| Type                             | Description                          |
| -------------------------------- | ------------------------------------ |
| `bank_statement`                 | Bank account statement               |
| `business_bank_statement`        | Business bank account statement      |
| `check`                          | Individual check                     |
| `list_of_checks_cashed`          | List of checks cashed                |
| `check_register`                 | Check register                       |
| `investment_statement`           | Investment / brokerage statement     |
| `retirement_account_statement`   | Retirement account statement         |
| `pension_statement`              | Pension statement                    |
| `annuity_award_letter`           | Annuity award letter                 |
| `social_security_statement`      | Social Security statement            |
| `social_security_cola_notice`    | Social Security COLA notice          |
| `disability_income_verification` | Disability income verification       |
| `credit_card_statement`          | Credit card statement                |
| `mortgage_statement`             | Mortgage statement                   |
| `auto_loan_statement`            | Auto loan statement                  |
| `student_loan_statement`         | Student loan statement               |
| `personal_loan_statement`        | Personal loan statement              |
| `heloc_statement`                | Home Equity Line of Credit statement |
| `loan_statement`                 | Loan statement (generic)             |

### Tax (9 types)

| Type         | Description                         |
| ------------ | ----------------------------------- |
| `form_1040`  | IRS Form 1040 (personal tax return) |
| `form_1120`  | IRS Form 1120 (C-Corporation)       |
| `form_1120s` | IRS Form 1120S (S-Corporation)      |
| `form_1065`  | IRS Form 1065 (Partnership)         |
| `w2_form`    | W-2 wage and tax statement          |
| `form_1099`  | 1099 tax form                       |
| `schedule_c` | IRS Schedule C (business income)    |
| `schedule_e` | IRS Schedule E (rental income)      |
| `tax_return` | Tax return (generic)                |

### Employment (7 types)

| Type                             | Description                           |
| -------------------------------- | ------------------------------------- |
| `pay_stub`                       | Pay stub / earnings statement         |
| `employment_verification_letter` | Employment verification letter        |
| `direct_deposit_verification`    | Direct deposit verification           |
| `unemployment_benefits_document` | Unemployment benefits document        |
| `military_les`                   | Military Leave and Earnings Statement |
| `offer_letter`                   | Offer letter                          |
| `self_employment_ledger`         | Self-employment ledger                |

### Property (6 types)

| Type                     | Description                |
| ------------------------ | -------------------------- |
| `property_deed`          | Property deed              |
| `property_tax_receipt`   | Property tax receipt       |
| `hoa_dues_statement`     | HOA / condo dues statement |
| `lease_agreement`        | Lease agreement            |
| `rental_receipt`         | Rental receipt             |
| `title_insurance_policy` | Title insurance policy     |

### Insurance (6 types)

| Type                                     | Description                            |
| ---------------------------------------- | -------------------------------------- |
| `homeowners_insurance_declarations_page` | Homeowners insurance declarations page |
| `homeowners_insurance_binder`            | Homeowners insurance binder            |
| `flood_insurance_declarations_page`      | Flood insurance declarations page      |
| `auto_insurance_declarations_page`       | Auto insurance declarations page       |
| `insurance_card`                         | Insurance card                         |
| `insurance_document`                     | Insurance policy document              |

### Commercial (6 types)

| Type                        | Description                               |
| --------------------------- | ----------------------------------------- |
| `business_license`          | Business license                          |
| `articles_of_incorporation` | Articles of incorporation                 |
| `profit_and_loss_statement` | Profit and loss statement                 |
| `utility_bill`              | Utility bill (electric, water, gas, etc.) |
| `phone_bill`                | Phone bill                                |
| `petty_cash_receipt`        | Petty cash receipt                        |

### Legal (7 types)

| Type                   | Description                             |
| ---------------------- | --------------------------------------- |
| `government_letter`    | Government letter (IRS, DMV, SSA, etc.) |
| `vehicle_registration` | Vehicle registration                    |
| `vehicle_title`        | Vehicle title                           |
| `court_order`          | Court order                             |
| `power_of_attorney`    | Power of attorney                       |
| `death_certificate`    | Death certificate                       |
| `marriage_certificate` | Marriage certificate                    |

Files that do not match a known type are classified as `other`.

## Analyzing a File

Submit a file for fraud detection via `POST /v1/detection`:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/detection \
  -H "x-api-key: YOUR_API_KEY" \
  -F "model=document" \
  -F "file=@invoice.pdf" \
  -F 'tags={"customerId":"9999","customerName":"Acme Corp","documentId":"INV-001","companyName":"DeepXL","companyId":"COMP-001"}'
```

### Parameters

| Parameter  | Type   | Required | Description                                                                                                                                                                                |
| ---------- | ------ | -------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| `model`    | string | Yes      | `document` or `object`                                                                                                                                                                     |
| `file`     | file   | Yes      | The file to analyze (max 50 MB)                                                                                                                                                            |
| `tags`     | string | No       | JSON object with metadata key-value pairs                                                                                                                                                  |
| `country`  | string | No       | Optional country hint. Supported values: `us`, `mx`, `br`. Missing, empty, or invalid values default to `us`.                                                                              |
| `document` | string | No       | Optional document type override for the document model, for example `bank_statement`, `business_bank_statement`, or `financial/bank_statement`. When supplied, classification is bypassed. |

<Warning>
  The maximum file size is **50 MB**. Files exceeding this limit will be rejected with a `413` error.
</Warning>

### Country Hint Behavior

Use the optional `country` parameter when you want the API to route or annotate the request with an explicit market hint.

* Supported values: `us`, `mx`, `br`
* Matching is case-insensitive
* Leading and trailing whitespace is ignored
* Missing, empty, or invalid values fall back to `us`

This is a **request hint**, not a detected issuer-country claim. The service stores the normalized value in metadata and returns it in the response when available.

Example:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/detection \
  -H "x-api-key: YOUR_API_KEY" \
  -F "model=document" \
  -F "file=@invoice.pdf" \
  -F "country=mx" \
  -F 'tags={"customerId":"9999","customerName":"Acme Corp","documentId":"INV-001","companyName":"DeepXL","companyId":"COMP-001"}'
```

## Response Structure

A detection response contains the following fields:

```json theme={null}
{
  "result": {
    "detectionId": 42,
    "mediaType": "document",
    "fileType": "pdf",
    "fileName": "bank_statement.pdf",
    "fileSize": 245678,
    "timestamp": 1725795600,
    "timestampISO": "2024-09-08T10:00:00.000000",
    "model": "document",
    "modelVersion": "1.1.0",
    "likelihood": 85.2,
    "fraudSeverity": "high",
    "classification": "verified",
    "reasoning": [
      "Potential manipulation detected in text region",
      "Font inconsistencies found"
    ],
    "modelResults": {
      "technicalChecks": [
        {
          "type": "DOCUMENT_CLASSIFIER",
          "status": "PASS",
          "details": "Classified as bank statement",
          "likelihood": 0.02
        },
        {
          "type": "SEMANTIC_FRAUD",
          "status": "FAIL",
          "details": "Detected inconsistencies in text formatting",
          "likelihood": 0.85
        }
      ]
    },
    "tags": [
      { "name": "customerId", "value": "9999" },
      { "name": "customerName", "value": "Acme Corp" },
      { "name": "documentId", "value": "INV-001" },
      { "name": "companyName", "value": "DeepXL" },
      { "name": "companyId", "value": "COMP-001" }
    ],
    "files": [
      {
        "category": "original_file",
        "fileName": "fd_42_bank_statement.pdf",
        "fileSize": 245678,
        "contentType": "application/pdf",
        "timestamp": 1725795600,
        "timestampISO": "2024-09-08T10:00:00.000000",
        "url": "https://api.deepxl.ai/v1/files/fd_42_bank_statement.pdf"
      },
      {
        "category": "heatmap",
        "fileName": "fd_42_heatmap_1.png",
        "fileSize": 45678,
        "contentType": "image/png",
        "timestamp": 1725795600,
        "timestampISO": "2024-09-08T10:00:00.000000",
        "url": "https://api.deepxl.ai/v1/files/fd_42_heatmap_1.png"
      }
    ]
  }
}
```

### Field Reference

| Field            | Type      | Description                                                  |
| ---------------- | --------- | ------------------------------------------------------------ |
| `detectionId`    | integer   | Unique identifier for the detection record                   |
| `mediaType`      | string    | Media type category (`image` or `document`)                  |
| `fileType`       | string    | File extension (`jpeg`, `png`, `pdf`, `webp`)                |
| `fileName`       | string    | Original uploaded file name                                  |
| `fileSize`       | integer   | File size in bytes                                           |
| `timestamp`      | integer   | Unix timestamp of the analysis                               |
| `timestampISO`   | string    | ISO 8601 timestamp of the analysis                           |
| `model`          | string    | Model used (`document` or `object`)                          |
| `modelVersion`   | string    | Version of the model used for analysis                       |
| `likelihood`     | float     | Fraud likelihood as a percentage (0–100)                     |
| `fraudSeverity`  | string    | Severity level: `low`, `medium`, or `high`                   |
| `classification` | string    | Quality assessment: `verified`, `unverified`, or `rejected`  |
| `reasoning`      | string\[] | Natural-language explanations of the analysis findings       |
| `modelResults`   | object    | Contains `technicalChecks` array with detailed check results |
| `tags`           | object\[] | Metadata tags attached to this detection                     |
| `files`          | object\[] | Associated files (original upload, heatmaps)                 |

## Understanding Results

### Likelihood Score

The `likelihood` field is a 0–100% score indicating the probability of fraud or manipulation:

| Range   | Severity | Interpretation                            |
| ------- | -------- | ----------------------------------------- |
| 0–29%   | `low`    | No significant indicators of manipulation |
| 30–69%  | `medium` | Some indicators of manipulation detected  |
| 70–100% | `high`   | Strong indicators of fraud detected       |

### Classification

The `classification` field indicates the document **quality assessment** — whether the document passed all quality gates and could be properly analyzed. This is separate from the fraud result (`likelihood` / `fraudSeverity`).

| Classification | Meaning                                                                                                             |
| -------------- | ------------------------------------------------------------------------------------------------------------------- |
| `verified`     | Document quality is good — passed all quality gates and was fully analyzed                                          |
| `unverified`   | Document quality is insufficient — image is blurry, corners are cut off, or semantic quality checks failed          |
| `rejected`     | Document type is not supported, text content is insufficient, or multiple documents were submitted in a single file |

### Reasoning

The `reasoning` array contains natural-language explanations of the analysis findings. Each entry describes a specific observation or conclusion from the forensic analysis.

## Technical Checks

The `modelResults.technicalChecks` array contains the individual forensic checks performed on the file. The number and type of checks varies depending on the model, file type, and document content.

Each check object includes:

| Field        | Type   | Description                                        |
| ------------ | ------ | -------------------------------------------------- |
| `type`       | string | Check identifier                                   |
| `status`     | string | `PASS`, `FAIL`, `WARNING`, or `NOT_PRESENT`        |
| `details`    | string | Human-readable explanation of the check result     |
| `likelihood` | float  | Confidence score for this specific check (0.0–1.0) |

### Status Values

| Status        | Meaning                                                                    |
| ------------- | -------------------------------------------------------------------------- |
| `PASS`        | Check passed — no issues found                                             |
| `FAIL`        | Check failed — issue detected                                              |
| `WARNING`     | Potential concern — not conclusive but worth noting                        |
| `NOT_PRESENT` | Check could not be performed — required data was not available in the file |

### Document Model

The `document` model runs a multi-stage pipeline. First, a series of **quality gates** determine the `classification` (whether the document can be properly analyzed). Then, **parallel fraud checks** analyze the document for manipulation and determine the `likelihood` score. Additional checks may run depending on the file type and document category.

### Object Model

The `object` model returns fraud detection results via the top-level `likelihood`, `fraudSeverity`, and `reasoning` fields. The `technicalChecks` array will be empty for the object model.

When AI generation or manipulation is detected, a **heatmap** is included in the `files` array highlighting the suspicious regions.

## Heatmaps

Both the `document` and `object` models can generate **heatmap images** that visually highlight the affected regions. Heatmaps make it easy to see exactly where tampering or AI generation was detected.

### How Heatmaps Work

* Heatmaps are **PNG images** overlaid on the original document or image
* **Document model**: for multi-page PDFs, each page gets its own heatmap (`fd_{id}_heatmap_1.png`, `fd_{id}_heatmap_2.png`, etc.)
* **Object model**: a single heatmap is generated per image (`fd_{id}_heatmap_1.png`)
* Heatmaps are only generated when manipulation or AI generation is detected
* They appear in the `files` array with `category: "heatmap"`

### Retrieving Heatmaps

Heatmap URLs are included in the detection response under `files`:

```json theme={null}
{
  "files": [
    {
      "category": "original_file",
      "fileName": "fd_42_bank_statement.pdf",
      "url": "https://api.deepxl.ai/v1/files/fd_42_bank_statement.pdf"
    },
    {
      "category": "heatmap",
      "fileName": "fd_42_heatmap_1.png",
      "url": "https://api.deepxl.ai/v1/files/fd_42_heatmap_1.png"
    },
    {
      "category": "heatmap",
      "fileName": "fd_42_heatmap_2.png",
      "url": "https://api.deepxl.ai/v1/files/fd_42_heatmap_2.png"
    }
  ]
}
```

Download a heatmap using the file retrieval endpoint:

```bash theme={null}
curl https://api.deepxl.ai/v1/files/fd_42_heatmap_1.png \
  -H "x-api-key: YOUR_API_KEY" \
  --output heatmap_page1.png
```

### File Categories

| Category        | Description                                                  |
| --------------- | ------------------------------------------------------------ |
| `original_file` | The file you originally uploaded                             |
| `heatmap`       | Generated heatmap highlighting detected manipulation regions |

## Error Codes

| Status | Error                  | Description                                                                                     |
| ------ | ---------------------- | ----------------------------------------------------------------------------------------------- |
| `400`  | Bad Request            | Invalid model name, invalid sort parameter, malformed JSON in tags, or invalid query parameters |
| `401`  | Unauthorized           | Missing or invalid API key                                                                      |
| `404`  | Not Found              | Detection record not found                                                                      |
| `413`  | Payload Too Large      | File exceeds the 50 MB maximum size                                                             |
| `415`  | Unsupported Media Type | File type is not supported by the selected model                                                |
| `500`  | Internal Server Error  | Unexpected server error — contact support if persistent                                         |
| `502`  | Bad Gateway            | Upstream analysis service is temporarily unavailable — retry after a short delay                |

## Tags and Filtering

Pass a JSON object in the `tags` parameter to attach metadata to your analysis:

```json theme={null}
{
  "customerId": "9999",
  "customerName": "Acme Corp",
  "documentId": "DOC-2024-001",
  "companyName": "DeepXL",
  "companyId": "COMP-001"
}
```

Filter your detection history by tags:

```bash theme={null}
curl "https://api.deepxl.ai/v1/detection?tagFilter=customerId=9999" \
  -H "x-api-key: YOUR_API_KEY"
```

## Browsing History

Retrieve paginated detection results with sorting and filtering:

```bash theme={null}
curl "https://api.deepxl.ai/v1/detection?limit=25&offset=0&sortBy=createdOn&direction=desc" \
  -H "x-api-key: YOUR_API_KEY"
```

### Query Parameters

| Parameter        | Type    | Description                                                       |
| ---------------- | ------- | ----------------------------------------------------------------- |
| `limit`          | integer | Number of results per page (default: 25)                          |
| `offset`         | integer | Number of results to skip                                         |
| `sortBy`         | string  | Field to sort by (see options below)                              |
| `direction`      | string  | `asc` or `desc`                                                   |
| `minLikelihood`  | float   | Minimum likelihood filter (0–100)                                 |
| `maxLikelihood`  | float   | Maximum likelihood filter (0–100)                                 |
| `fraudSeverity`  | string  | Filter by severity: `low`, `medium`, or `high`                    |
| `classification` | string  | Filter by classification: `verified`, `unverified`, or `rejected` |
| `tagFilter`      | string  | Filter by tag (format: `key=value`)                               |
| `minTimestamp`   | integer | Minimum Unix timestamp                                            |
| `maxTimestamp`   | integer | Maximum Unix timestamp                                            |

### Sort Options

`fraudDetectionId`, `fileName`, `fileSize`, `fileType`, `model`, `likelihood`, `createdOn`


# ID Verification
Source: https://docs.deepxl.ai/en/guides/id-verification

Verify identity by matching an ID document against a selfie image or video

The ID-Selfie Model verifies a person's identity by matching their ID document against a selfie image or video. It performs face matching and anti-spoofing checks.

## How It Works

1. Upload an **ID document** (passport, driver license, etc.)
2. Upload a **selfie image or video** of the person
3. The API compares the faces and runs anti-spoofing checks
4. You receive a `verified` boolean and detailed technical checks

## Verifying Identity

Submit both files via `POST /v1/verification`:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/verification \
  -H "x-api-key: YOUR_API_KEY" \
  -F "idFile=@passport.jpg" \
  -F "selfieFile=@selfie.jpg" \
  -F 'tags={"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-001","companyName":"DeepXL","companyId":"COMP-001"}'
```

### Parameters

| Parameter    | Type   | Required | Description                                                                                                   |
| ------------ | ------ | -------- | ------------------------------------------------------------------------------------------------------------- |
| `idFile`     | file   | Yes      | ID document image (passport, driver license, etc.)                                                            |
| `selfieFile` | file   | Yes      | Selfie image or video of the person                                                                           |
| `tags`       | string | No       | JSON object with metadata key-value pairs                                                                     |
| `country`    | string | No       | Optional country hint. Supported values: `us`, `mx`, `br`. Missing, empty, or invalid values default to `us`. |

### Supported File Types

**ID document:** jpg, jpeg, png, webp

**Selfie:** jpg, jpeg, png, webp, mp4 (video)

## Response Structure

```json theme={null}
{
  "result": {
    "verificationId": 5,
    "idFileType": "jpeg",
    "idFileName": "passport.jpg",
    "idFileSize": 174112,
    "selfieFileType": "jpeg",
    "selfieFileName": "selfie.jpg",
    "selfieFileSize": 250118,
    "timestamp": 1770984835,
    "timestampISO": "2026-02-13T13:13:55.213189",
    "model": "verification",
    "modelVersion": "1.0.0",
    "verified": true,
    "modelResults": {
      "technicalChecks": [
        {
          "checkType": "face_detection",
          "faceCount": { "id": 2, "selfie": 1 },
          "idFaces": [
            {
              "faceId": "face_1",
              "detectionConfidence": 0.9992,
              "landmarks": {
                "nose": { "x": 257.7, "y": 946.13 },
                "left_eye": { "x": 287.49, "y": 911.67 },
                "right_eye": { "x": 227.69, "y": 911.25 },
                "mouth_left": { "x": 283.88, "y": 971.12 },
                "mouth_right": { "x": 232.78, "y": 971.0 }
              },
              "boundingBox": { "x1": 195, "x2": 318, "y1": 838, "y2": 1013 }
            },
            {
              "faceId": "face_2",
              "detectionConfidence": 0.9865,
              "landmarks": {
                "nose": { "x": 696.46, "y": 885.83 },
                "left_eye": { "x": 701.44, "y": 879.83 },
                "right_eye": { "x": 690.77, "y": 880.29 },
                "mouth_left": { "x": 701.06, "y": 891.11 },
                "mouth_right": { "x": 692.61, "y": 891.52 }
              },
              "boundingBox": { "x1": 684, "x2": 707, "y1": 866, "y2": 898 }
            }
          ],
          "selfieFaces": [
            {
              "faceId": "face_1",
              "detectionConfidence": 0.9985,
              "landmarks": {
                "nose": { "x": 724.91, "y": 807.64 },
                "left_eye": { "x": 803.63, "y": 708.27 },
                "right_eye": { "x": 649.76, "y": 710.14 },
                "mouth_left": { "x": 793.35, "y": 871.12 },
                "mouth_right": { "x": 659.28, "y": 871.8 }
              },
              "boundingBox": { "x1": 569, "x2": 884, "y1": 523, "y2": 986 }
            }
          ]
        }
      ]
    },
    "tags": [
      { "name": "customerId", "value": "9999" },
      { "name": "customerName", "value": "Acme Corp" },
      { "name": "documentId", "value": "DOC-001" },
      { "name": "companyName", "value": "DeepXL" },
      { "name": "companyId", "value": "COMP-001" }
    ],
    "files": [
      {
        "category": "id",
        "fileName": "passport.jpg",
        "fileSize": 174112,
        "contentType": "image/jpeg",
        "timestamp": 1770984835,
        "timestampISO": "2026-02-13T13:13:55.213189",
        "url": "https://api.deepxl.ai/v1/files/v_id_5_passport.jpg"
      },
      {
        "category": "face",
        "fileName": "selfie.jpg",
        "fileSize": 250118,
        "contentType": "image/jpeg",
        "timestamp": 1770984835,
        "timestampISO": "2026-02-13T13:13:55.213189",
        "url": "https://api.deepxl.ai/v1/files/v_face_5_selfie.jpg"
      }
    ]
  }
}
```

### Field Reference

| Field            | Type    | Description                                   |
| ---------------- | ------- | --------------------------------------------- |
| `verificationId` | integer | Unique identifier for the verification record |
| `idFileType`     | string  | File extension of the ID document             |
| `idFileName`     | string  | Original file name of the ID document         |
| `idFileSize`     | integer | File size of the ID document in bytes         |
| `selfieFileType` | string  | File extension of the selfie                  |
| `selfieFileName` | string  | Original file name of the selfie              |
| `selfieFileSize` | integer | File size of the selfie in bytes              |
| `timestamp`      | integer | Unix timestamp of the analysis                |
| `timestampISO`   | string  | ISO 8601 timestamp of the analysis            |
| `model`          | string  | Model used (`verification`)                   |
| `modelVersion`   | string  | Version of the model used for analysis        |
| `verified`       | boolean | Whether the identity was confirmed            |

### Verified

The `verified` field is a boolean indicating whether the identity was confirmed — the face in the selfie matches the face in the ID document and anti-spoofing checks passed.

### Technical Checks

The `modelResults.technicalChecks` array contains face detection results for both the ID document and the selfie.

**Face Detection** (`checkType: "face_detection"`):

| Field         | Type   | Description                                              |
| ------------- | ------ | -------------------------------------------------------- |
| `faceCount`   | object | Number of faces detected — `id` count and `selfie` count |
| `idFaces`     | array  | Faces detected in the ID document                        |
| `selfieFaces` | array  | Faces detected in the selfie                             |

**Each face object includes:**

| Field                 | Type   | Description                                                                                |
| --------------------- | ------ | ------------------------------------------------------------------------------------------ |
| `faceId`              | string | Face identifier (e.g. `face_1`, `face_2`)                                                  |
| `detectionConfidence` | float  | Face detection confidence (0.0–1.0)                                                        |
| `landmarks`           | object | Facial landmark coordinates (`nose`, `left_eye`, `right_eye`, `mouth_left`, `mouth_right`) |
| `boundingBox`         | object | Face bounding box coordinates (`x1`, `y1`, `x2`, `y2`)                                     |

### File Categories

| Category | Description                        |
| -------- | ---------------------------------- |
| `id`     | The uploaded ID document           |
| `face`   | The uploaded selfie image or video |

## Tags and Filtering

```bash theme={null}
curl "https://api.deepxl.ai/v1/verification?tagFilter=customerId=9999" \
  -H "x-api-key: YOUR_API_KEY"
```

## Browsing History

```bash theme={null}
curl "https://api.deepxl.ai/v1/verification?limit=25&offset=0&sortBy=verificationId&direction=desc" \
  -H "x-api-key: YOUR_API_KEY"
```

### Sort Options

`verificationId`, `idFileName`, `idFileSize`, `idFileType`, `selfieFileName`, `selfieFileSize`, `selfieFileType`, `verified`, `timestamp`


# Introduction
Source: https://docs.deepxl.ai/en/introduction

Forensic AI for document/object fraud detection, identity verification, and data extraction

# Welcome to DeepXL

DeepXL is a forensic AI platform that detects manipulated documents, verifies identities, and extracts structured data — built for lenders, insurers, and government. Integrate via a simple API to catch AI-generated fraud that legacy systems miss.

## Our Models

<CardGroup>
  <Card title="Document Model" icon="file-shield" href="/guides/fraud-detection">
    Detects AI-generated or altered documents and IDs — bank statements, invoices, passports, driver licenses, and more.
  </Card>

  <Card title="Object Model" icon="image" href="/guides/fraud-detection">
    Detects whether an image has been AI-generated or manipulated — photos, claim evidence, receipts, and other visual content.
  </Card>

  <Card title="Parsing Model" icon="file-lines" href="/guides/document-parsing">
    Extracts and parses structured data from IDs and documents — names, dates, addresses, amounts, and more.
  </Card>

  <Card title="ID-Selfie Model" icon="id-card" href="/guides/id-verification">
    Verifies identity by matching an ID document against a selfie image or video.
  </Card>
</CardGroup>

## Model Details

### Document Model

Detects AI-generated, digitally altered, or tampered documents — including bank statements, pay stubs, invoices, passports, and driver licenses.

**What it analyzes:**

* Pixel-level manipulation artifacts and metadata inconsistencies
* Font, layout, and formatting anomalies inconsistent with the issuing source
* Signs of generative AI fabrication (synthetic documents with no original)

### Object Model

Detects whether a photo or visual asset has been AI-generated or manipulated — covering claim evidence photos, product images, receipts, and general visual content.

**What it analyzes:**

* GAN/diffusion model generation signatures
* Image splicing, cloning, and compositing artifacts
* Lighting, shadow, and perspective inconsistencies

### Parsing Model

Extracts and normalizes structured data from identity documents and financial records — eliminating the need for manual data entry or custom OCR pipelines.

**What it analyzes:**

* Identity documents (driver licenses, state IDs, passports, Social Security cards)
* Financial records (bank statements, pay stubs)
* Extracts fields such as names, dates, amounts, account numbers, and document numbers

### ID-Selfie Model

Verifies that a person presenting an ID document is the same individual captured in a selfie image or short video — combining liveness detection with facial matching.

**What it analyzes:**

* Biometric similarity between the ID photo and the selfie or video frame
* Liveness signals to prevent spoofing (printed photos, screen replays, deepfakes)
* Facial landmark detection and bounding box coordinates for both inputs

## How It Works

1. **Authenticate** with an API key
2. **Upload** a document or image to an analysis endpoint
3. **Receive** structured results with fraud scores, quality classifications, and detailed reasoning
4. **Retrieve** associated files (originals, heatmaps) via the file retrieval endpoint

## Supported File Types

| Format      | Document Model | Object Model | Parsing Model | ID-Selfie Model |
| ----------- | :------------: | :----------: | :-----------: | :-------------: |
| JPEG / JPG  |       Yes      |      Yes     |      Yes      |       Yes       |
| PNG         |       Yes      |      Yes     |      Yes      |       Yes       |
| WebP        |       Yes      |      Yes     |      Yes      |       Yes       |
| PDF         |       Yes      |      No      |      Yes      |        No       |
| MP4 / Video |       No       |      No      |       No      |       Yes       |

## Next Steps

<CardGroup>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Make your first API call in minutes.
  </Card>

  <Card title="Authentication" icon="key" href="/authentication">
    Learn how to authenticate your requests.
  </Card>
</CardGroup>


# Quickstart
Source: https://docs.deepxl.ai/en/quickstart

Make your first API call in under 5 minutes

## 1. Get Your API Key

Sign in to the [DeepXL Console](https://console.deepxl.ai) and create an API key from the **API Keys** section.

## 2. Detect Document Fraud

Upload a file to the Document Model to check for manipulation:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/detection \
  -H "x-api-key: YOUR_API_KEY" \
  -F "model=document" \
  -F "file=@bank_statement.pdf" \
  -F 'tags={"customerId":"9999","customerName":"Acme Corp","documentId":"DOC-001","companyName":"DeepXL","companyId":"COMP-001"}'
```

You will receive a response with a fraud likelihood score (0–100%), severity level (`low`, `medium`, `high`), quality classification (`verified`, `unverified`, `rejected`), and detailed reasoning:

```json theme={null}
{
  "result": {
    "detectionId": 42,
    "mediaType": "document",
    "fileType": "pdf",
    "fileName": "bank_statement.pdf",
    "fileSize": 245678,
    "timestamp": 1725795600,
    "timestampISO": "2024-09-08T10:00:00.000000",
    "model": "document",
    "modelVersion": "1.1.0",
    "likelihood": 15.5,
    "fraudSeverity": "low",
    "classification": "verified",
    "reasoning": [
      "Document structure appears authentic",
      "No manipulation detected"
    ],
    "modelResults": {
      "technicalChecks": [
        { "type": "DOCUMENT_CLASSIFIER", "status": "PASS", "details": "Classified as bank statement", "likelihood": 0.0 },
        { "type": "SEMANTIC_QUALITY", "status": "PASS", "details": "Image quality is acceptable", "likelihood": 0.0 },
        { "type": "SEMANTIC_FRAUD", "status": "PASS", "details": "No tampering indicators found", "likelihood": 0.0 }
      ]
    },
    "files": [
      {
        "category": "original_file",
        "fileName": "fd_42_bank_statement.pdf",
        "url": "https://api.deepxl.ai/v1/files/fd_42_bank_statement.pdf"
      }
    ]
  }
}
```

## 3. Extract Data from a Document

Use the Parsing Model to extract structured data from an ID:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/parse \
  -H "x-api-key: YOUR_API_KEY" \
  -F "model=light" \
  -F "file=@drivers_license.jpg"
```

```json theme={null}
{
  "result": {
    "parseId": 117,
    "mediaType": "image",
    "fileType": "jpeg",
    "fileName": "drivers_license.jpg",
    "fileSize": 231433,
    "timestamp": 1725795600,
    "timestampISO": "2024-09-08T10:00:00.000000",
    "model": "light",
    "modelVersion": "1.2.0",
    "documentType": "idDocument",
    "parsedData": {
      "firstName": "JOHN",
      "lastName": "DOE",
      "dateOfBirth": "1990-05-15",
      "licenseNumber": "D1234567",
      "expirationDate": "2028-05-15",
      "address": "123 MAIN ST ANYTOWN, CA 90210"
    },
    "files": [
      {
        "category": "original_file",
        "fileName": "drivers_license.jpg",
        "url": "https://api.deepxl.ai/v1/files/parse_117_drivers_license.jpg"
      }
    ]
  }
}
```

## 4. Verify Identity

Use the ID-Selfie Model to match a person's ID against their selfie:

```bash theme={null}
curl -X POST https://api.deepxl.ai/v1/verification \
  -H "x-api-key: YOUR_API_KEY" \
  -F "idFile=@passport.jpg" \
  -F "selfieFile=@selfie.jpg"
```

```json theme={null}
{
  "result": {
    "verificationId": 457,
    "idFileName": "passport.jpg",
    "selfieFileName": "selfie.jpg",
    "timestamp": 1725795600,
    "timestampISO": "2024-09-08T10:00:00.000000",
    "model": "verification",
    "modelVersion": "1.0.0",
    "verified": true,
    "modelResults": {
      "technicalChecks": [
        {
          "checkType": "face_detection",
          "likelihood": 99.85,
          "faceCount": { "id": 1, "selfie": 1 },
          "idFaces": [
            { "faceId": "face_1", "detectionConfidence": 0.9992 }
          ],
          "selfieFaces": [
            { "faceId": "face_1", "detectionConfidence": 0.9985 }
          ]
        }
      ]
    },
    "files": [
      {
        "category": "id",
        "fileName": "passport.jpg",
        "url": "https://api.deepxl.ai/v1/files/v_id_457_passport.jpg"
      },
      {
        "category": "face",
        "fileName": "selfie.jpg",
        "url": "https://api.deepxl.ai/v1/files/v_face_457_selfie.jpg"
      }
    ]
  }
}
```

## What's Next?

<CardGroup>
  <Card title="Authentication" icon="key" href="/authentication">
    Learn about API key authentication.
  </Card>

  <Card title="Fraud Detection Guide" icon="shield-check" href="/guides/fraud-detection">
    Document and Object models, likelihood scores, and filtering.
  </Card>
</CardGroup>