> This page is for NT Connect.

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://partner.ninjatrader.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://partner.ninjatrader.com/_mcp/server.

# Identity Check Request

POST https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest
Content-Type: application/json

### Run the identity check for a customer application.

**Available to:** Approved business-to-business account-opening partners

**Environments:** Live

Run the required identity check after submitting the applicant details with [`submitApplicant`](/connect/api/rest-api-endpoints/users/submit-applicant) and before preparing the account agreements.

Provide `customerApplication.id` from the [`startCustomerApplication`](/connect/api/rest-api-endpoints/users/start-customer-application) response as `customerApplicationId`. The response reports the identity-check `result` and can include follow-up `questions` and a `journeyApplicationToken`.

**Identity-Verification Rollout Option**

`isDarkLaunchEnabled` is an optional boolean for the primary applicant's supported identity-verification journey:

| Value | Behavior |
|---|---|
| `true` | Requests the configured rollout journey version, when one is configured. Enable this option only as directed by NinjaTrader during rollout onboarding. |
| `false` or omitted | Sends no journey-version override. Leave the field unset for the standard integration unless NinjaTrader instructs you otherwise. |

This option doesn't select the verification provider and doesn't apply to joint-applicant checks. It doesn't bypass identity verification or indicate that the application is approved.

A `ReviewNeeded` result means the application requires review; it does not mean the application is approved. Continue with the agreement flow, then track the application to a final status with [`customerApplicationItem`](/connect/api/rest-api-endpoints/users/customer-application-item).

Questionnaire submission is outside this guide's partner API scope. If the response includes follow-up questions or a journey token, preserve the data with the application and coordinate the next steps with your NinjaTrader onboarding contact. Don't attempt an undocumented questionnaire-submission call.

**Next Steps**

- Generate the applicant's account agreements with [`prepareAgreementDocuments`](/connect/api/rest-api-endpoints/users/prepare-agreement-documents).

Reference: https://partner.ninjatrader.com/connect/api/rest-api-endpoints/users/identity-check-request

## Authentication

- `Authorization` header (bearer token, required) — Bearer authentication of the form `Bearer <token>`, where token is your auth token.

## Request

### Body (application/json)

This endpoint expects an IdentityCheckRequest.

- `customerApplicationId` (long, required)
- `iovationBlackbox` (string, optional)
- `isDarkLaunchEnabled` (boolean, optional) — For the primary applicant's supported identity-verification journey, true requests the configured rollout version. If false or omitted, no journey-version override is sent. Enable only as directed by NinjaTrader.

## Response

### 200

IdentityCheckResponse

- `questions` (list of IdentityCheckQuestion, required)
- `errorText` (string, optional) — Non-empty if the request failed
- `result` (enum, optional) — Fail, Pass, ReviewNeeded
  - Allowed values: `Fail`, `Pass`, `ReviewNeeded`
- `journeyApplicationToken` (string, optional)

## Types

### IdentityCheckQuestion

- `id` (integer, required)
- `text` (string, required)
- `answers` (list of string, required)

## Examples

**Request**

```json
{
  "customerApplicationId": 123456
}
```

**Response**

```json
{
  "questions": [
    {
      "id": 1,
      "text": "Select the address you recognize.",
      "answers": [
        "100 Example Street",
        "200 Example Avenue",
        "None of the above"
      ]
    }
  ],
  "result": "ReviewNeeded"
}
```

**SDK Code**

```python
import requests

url = "https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest"

payload = { "customerApplicationId": 123456 }
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

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

print(response.json())
```

```javascript
const url = 'https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest';
const options = {
  method: 'POST',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{"customerApplicationId":123456}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest"

	payload := strings.NewReader("{\n  \"customerApplicationId\": 123456\n}")

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

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

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

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

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"customerApplicationId\": 123456\n}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"customerApplicationId\": 123456\n}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest', [
  'body' => '{
  "customerApplicationId": 123456
}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest");
var request = new RestRequest(Method.POST);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"customerApplicationId\": 123456\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["customerApplicationId": 123456] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://live.tradovateapi.com/v1/customerApplication/identitycheckrequest")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```