// File: api/authentication
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# Authentication
## Host
The base domain for the Real ID API is `https://real-id.getverdict.com/api/v1`.
All endpoints use this as the base URL.
## API keys
Real ID's REST API uses `Bearer` tokens for authentication.
You can find your token within the Real ID dashboard, under **Settings > DevTools**.
Your license key is also your Real ID API token. You can find your live license keys by logging into the [billing dashboard](https://dashboard.getverdict.com), or opening the settings of the plugin and opening the **Billing** section.
You can find your token within the Real ID dashboard, under **Settings > DevTools**.
You can find your live and test API keys in the Real ID dashboard under **Developers**.
Once you have your API key, pass it into the `Authorization` header, and prefix the token with `Bearer {{yourApiKey}}`.
```javascript
import axios from "axios";
// Send an ID check to John Smith at johnsmith@gmail.com
await axios.post(
"https://real-id.getverdict.com/api/v1/checks",
{
firstName: "John",
lastName: "Smith",
email: "johnsmith@gmail.com",
},
{
headers: {
Authorization: `Bearer ${yourApiKey}`,
},
}
);
```
---
// File: api/checks
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# Checks
Interact with the Real ID checks API to retrieve and create ID checks for customers.
## Create an ID check
To create an ID check via the API, you need to pass at minimum an **email address** or **phone number**.
But the more details the better, so the system can properly personalize the email and SMS message to the customer according to your templates.
```
POST https://real-id.getverdict.com/api/v1/checks
```
### Parameters
In the body of the request, define the `customer` and the `order` if possible.
We recommend providing as much details as possible for the best synchonization of ID verification to Shopify tags on the customer and order.
However, the only required fields are at least an `customer.email` or a `customer.phone` to at minimum be able to deliver the ID check to the customer.
:::tip
If present, the `order.shopify_admin_graphql_id` and `customer.shopify_admin_graphql_id` will be used to sync the ID check changes to the corresponding order and customer.
For example, when the customer completes the ID check their order will be tagged with `ID verification completed`.
For WooCommerce, the same behavior applies when the `order.wc_id` or `customer.wc_id` parameters are given.
For BigCommerce and Custom integrations, use the `order.name` field to associate the check with an order. The check results will still be available in the Real ID dashboard and via the API.
:::
```json
{
"customer": {
"first_name": "John",
"last_name": "Smith",
"email": "johnsmith@gmail.com",
"phone": "+1224225555",
"shopify_admin_graphql_id": "gid://shopify/Customer/1234"
},
"order": {
"shopify_admin_graphql_id": "gid://shopify/Order/1234",
"name": "#1234"
}
}
```
```json
{
"customer": {
"first_name": "John",
"last_name": "Smith",
"email": "johnsmith@gmail.com",
"phone": "+1224225555",
"wc_id": 1234
},
"order": {
"wc_id": 5678
}
}
```
```json
{
"customer": {
"first_name": "John",
"last_name": "Smith",
"email": "johnsmith@gmail.com",
"phone": "+1224225555"
},
"order": {
"name": "#1234"
}
}
```
```json
{
"customer": {
"first_name": "John",
"last_name": "Smith",
"email": "johnsmith@gmail.com",
"phone": "+1224225555"
},
"order": {
"name": "#1234"
}
}
```
:::info
Please note that any settings you provide in the ID check will override your settings defined in the Real ID app. So if you only provide the customer and order details for example, then your [custom content](../theming/customize-content.md), [branding](../theming/branding.md), [rules like selfie capture](../rules/face-match.md), [automatic reminders](../for-merchants/automatic-id-check-reminders.md) etc. defined in the app will be applied to these API created checks.
:::
#### Customizing Check Theme & Content
By default, the ID check will use the content defined in the **Settings** area of the Real ID app. But you can control the content per ID check using the API instead.
You can pass a custom message to the `check.intro_content` parameter, as well as customize the theme using the `check.theme` parameter:
```json
{
"customer": {
"first_name": "John",
"last_name": "Smith",
"email": "johnsmith@gmail.com",
"phone": "+1224225555",
"shopify_admin_graphql_id": "gid://shopify/Customer/1234"
},
"order": {
"shopify_admin_graphql_id": "gid://shopify/Order/1234",
"name": "#1234"
},
"check": {
"intro_content": "Hi [firstName], \n Your order [orderId] requires ID verification because it has been flagged as high risk by Shopify. \n Your order will process as soon as you complete ID verification, this is just an extra security measure to prevent misuse of your credit card."
"theme": {
"primary_color": "#FFFFFF",
"button_color: "#000000",
"logo_url": "https://example.com/logo.png"
}
}
}
```
The `check.intro_content` parameter supports [short codes](../theming/customize-content.md#shortcodes) to reference data from the order and customer details.
The `check.theme.primary_color` and `check.theme.button_color` support color HEX codes.
:::tip Custom logo images must be publicly available
Please provide a publicly available URL for the `check.theme.logo_url`, this URL will be used for both the email to customers as well as in the online ID verification flow.
:::
#### Customizing ID check requirements
You can control if the ID check should require just an ID photo or both the ID photo and a matching headshot for additional verification with the `check.images_required` parameter.
```json
{
"customer": {
"first_name": "John",
"last_name": "Smith",
"email": "johnsmith@gmail.com",
"phone": "+1224225555",
"shopify_admin_graphql_id": "gid://shopify/Customer/1234"
},
"order": {
"shopify_admin_graphql_id": "gid://shopify/Order/1234",
"name": "#1234"
},
"check": {
"images_required": "id"
}
}
```
The `check.images_required` accepts two different options:
- `"id"` - only the ID photo is required for verification
- `"idv"` - both the ID photo and a matching headshot are required for verification
#### Requiring an additional document
You can require the customer to upload an additional document as part of their ID check — such as a hunting license, professional certification, or any custom document.
Use the `check.additional_document` parameter to define the document requirement per check:
```json
{
"customer": {
"first_name": "John",
"last_name": "Smith",
"email": "johnsmith@gmail.com",
"phone": "+1224225555"
},
"order": {
"name": "#1234"
},
"check": {
"additional_document": {
"required": true,
"type": "hunting_license",
"title": "Hunting License",
"description": "Please upload a photo of your valid state hunting license."
}
}
}
```
The `additional_document` object accepts the following fields:
| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `required` | boolean | Yes | When `true`, the customer will be asked to upload the document during the ID check flow. |
| `type` | string | No | A machine-readable slug identifying the document type (e.g. `"hunting_license"`, `"professional_cert"`). Useful for programmatic tracking and webhook consumers. |
| `title` | string | Yes | The heading shown to the customer on the document upload step. |
| `description` | string | Yes | Body text explaining what the customer should upload. |
:::tip
This is different from the shop-level [Proof of Address](../rules/proof-of-address.md) setting, which applies to all checks. The `additional_document` parameter lets you dynamically control the requirement and customize the content per check via the API.
When both are configured, the per-check `additional_document` title and description take priority over the shop-level proof of address content.
:::
The `additional_document` is also returned in the response when retrieving a check:
```json
{
"check": {
"id": "7TWFOC-auPI",
"step": "delivered",
"additional_document": {
"type": "hunting_license",
"title": "Hunting License",
"description": "Please upload a photo of your valid state hunting license."
}
}
}
```
#### Multiple additional documents
If you're using advanced rules with the **multi-additional-documents** experiment enabled, a single check can require multiple documents. The `additional_documents` array (plural) exposes every document the customer **engaged with** — uploaded, had AI extraction run against, etc. OR-group alternatives the customer never touched are filtered out so the response only carries meaningful evaluation results. If no document has been engaged with yet, the `additional_documents` key is omitted entirely.
```json
{
"check": {
"id": "7TWFOC-auPI",
"step": "completed",
"additional_documents": [
{
"id": "ct-ammo-cert",
"type": "custom",
"title": "Connecticut Ammunition Certificate",
"description": "Please upload a clear photo of your active Connecticut Ammunition Certificate.",
"verdict": true,
"detected_document_type": "Connecticut Ammunition Certificate",
"field_errors": [],
"extracted_fields": {
"holder_name": "Jane Doe",
"document_number": "CT-AMMO-12345",
"issue_date": "2024-03-15",
"expiration_date": "2029-03-15"
}
},
{
"id": "ffl",
"type": "custom",
"title": "Federal Firearms License (FFL)",
"description": "Please upload a clear photo of your active Federal Firearms License.",
"verdict": false,
"detected_document_type": "Federal Firearms License",
"field_errors": [
{
"field": "expiration_date",
"ruleType": "date_in_future",
"message": "The expiration date on your document is expired.",
"severity": "hard_fail"
}
],
"extracted_fields": {
"license_holder": "Jane Doe FFL LLC",
"license_number": "1-23-456-78-9A-12345",
"license_type_code": "01",
"expiration_date": "2024-01-31",
"premises_address": "100 Main St, Hartford, CT 06103"
}
}
]
}
}
```
Each entry includes:
| Field | Type | Description |
|---|---|---|
| `id` | string | Stable id referenced by rule configurations. |
| `type` | string | Document type (e.g. `custom`, `proofOfAddress`, `firearmLicense`). |
| `title` | string | Customer-facing heading for the capture step. |
| `description` | string | Customer-facing body text. |
| `verdict` | boolean \| null | `true` if the capture passed automated document verification and field validation, `false` on a hard fail. (`null` is theoretically possible if a prediction was recorded without a verdict, but in practice every entry returned here is engaged so `verdict` is always `true` or `false`.) |
| `detected_document_type` | string \| null | The document type Real ID identified from the upload. Useful for diagnosing type mismatches. |
| `field_errors` | array | Per-field validation failures. Empty when the capture is clean. Each entry has `field`, `ruleType`, `message`, `severity` (`retake` or `hard_fail`). |
| `extracted_fields` | object | Values Real ID's AI extracted from the document, keyed by the field's machine name (matches the `key` in your document's `fields[]` configuration). Empty `{}` when the customer hasn't uploaded yet or the document type was rejected. Values are strings or `null`. Use these alongside `verdict` and `field_errors` for downstream logic — e.g. branching on `extracted_fields.license_type_code` to set merchant-side metafields. |
The singular `additional_document` (above) is still returned for backward compatibility and reflects the first entry in `additional_documents`.
:::tip Sandbox / Test mode
When the check is in [Test Mode](../getting-started/test-mode.md) (`testing: true`), Real ID skips real AI extraction and auto-fills `extracted_fields` with deterministic placeholder values keyed off your document's field configuration. Each value is picked to satisfy that field's `validations` so the response always comes back as `verdict: true`. Use sandbox checks to wire and verify your integration (metafield flips, branching logic, etc.) end-to-end before going live.
Examples:
| Field config | Sandbox value |
|---|---|
| `valueType: "date"`, `validations: [{ type: "date_in_future" }]` | `"2030-12-31"` |
| `valueType: "date"`, `validations: [{ type: "date_in_past" }]` (key contains `dob` or `birth`) | `"1985-06-15"` |
| `valueType: "date"`, `validations: [{ type: "date_in_past" }]` (other keys) | `"2020-01-01"` |
| `valueType: "string"`, `validations: [{ type: "regex", pattern: "^03$" }]` | `"03"` |
| `valueType: "string"`, `validations: [{ type: "regex", pattern: "^(01\|02\|06)$" }]` | `"01"` (first alternative) |
| `valueType: "string"` with no regex | `"Sandbox {label}"` |
| `valueType: "image"` | `null` |
:::
#### Skip emails and SMS messages
By default, the API will automatically send an email and text message to the customer with the ID check link. However, this may be an issue for testing, since you may want to use testing email addresses, or perhaps you want to better control messaging to your customers.
You can disable the email and SMS message by passing the `deliver_checks` option to the `options` in the request:
```json
{
"customer": {
"email": "example@test.com"
},
"options": {
"deliver_check": false
}
}
```
This will simply create and return the ID check, but not deliver the ID check to the customer.
### Response
After creating the ID check, the API will respond with a format like this:
```json
{
"message": "Delivered ID check",
"check": {
"order": {
"id": "gid://shopify/Order/1234",
"name": "#1234"
},
"customer": {
"first_name": "John",
"last_name": "Smith",
"id": "gid://shopify/Customer/1234",
"phone": "+1224225555",
"email": "johnsmith@gmail.com"
},
"rules": {
"testing": true,
"signature_required": false,
"id_check_type": "idv",
"include_back_of_id": false,
"selfie_liveness": "straight"
},
"result": {
"scores": {},
"document": {}
},
"id": "7TWFOC-auPI",
"step": "delivered",
"shop_name": "real-id-dev.myshopify.com",
"created_at": "2023-03-14T03:22:00.219Z",
"platform": "shopify"
}
}
```
```json
{
"message": "Delivered ID check",
"check": {
"order": {
"id": 5678
},
"customer": {
"first_name": "John",
"last_name": "Smith",
"id": 1234,
"phone": "+1224225555",
"email": "johnsmith@gmail.com"
},
"rules": {
"testing": true,
"signature_required": false,
"id_check_type": "idv",
"include_back_of_id": false,
"selfie_liveness": "straight"
},
"result": {
"scores": {},
"document": {}
},
"id": "7TWFOC-auPI",
"step": "delivered",
"shop_name": "real-id-dev.myshopify.com",
"created_at": "2023-03-14T03:22:00.219Z",
"platform": "wc"
}
}
```
```json
{
"message": "Delivered ID check",
"check": {
"order": {
"name": "#1234"
},
"customer": {
"first_name": "John",
"last_name": "Smith",
"phone": "+1224225555",
"email": "johnsmith@gmail.com"
},
"rules": {
"testing": true,
"signature_required": false,
"id_check_type": "idv",
"include_back_of_id": false,
"selfie_liveness": "straight"
},
"result": {
"scores": {},
"document": {}
},
"id": "7TWFOC-auPI",
"step": "delivered",
"created_at": "2023-03-14T03:22:00.219Z",
"platform": "bc"
}
}
```
```json
{
"message": "Delivered ID check",
"check": {
"order": {
"name": "#1234"
},
"customer": {
"first_name": "John",
"last_name": "Smith",
"phone": "+1224225555",
"email": "johnsmith@gmail.com"
},
"rules": {
"testing": true,
"signature_required": false,
"id_check_type": "idv",
"include_back_of_id": false,
"selfie_liveness": "straight"
},
"result": {
"scores": {},
"document": {}
},
"id": "7TWFOC-auPI",
"step": "delivered",
"created_at": "2023-03-14T03:22:00.219Z",
"platform": "standalone"
}
}
```
:::note
There are fields automatically added to the ID check based on your settings within the app.
To change the liveness rules, or minimum age rules, open the **Rules** area in the **Settings** of the dashboard.
:::
## Retrieve an ID check
To retrieve an ID check, provide the unique ID of the check as a route parameter.
```
GET https://real-id.getverdict.com/api/v1/checks/{{checkId}}
```
### Finding the check ID for a customer or order
Real ID writes the most recent check ID to the customer and order on your store, so you can look it up without storing it yourself. The field name and access pattern depends on your platform.
On Shopify, the check ID is stored in the `real_id.check_id` [metafield](../shopify/metafields.md#real_idcheck_id-metafield) on both the customer and the order.
Read it in a Liquid template:
```liquid
{{ customer.metafields.real_id.check_id }}
{{ order.metafields.real_id.check_id }}
```
Or read it with the Shopify Admin GraphQL API:
```gql
query getOrderCheckId($orderId: ID!) {
order(id: $orderId) {
metafield(namespace: "real_id", key: "check_id") {
value
}
}
}
```
```gql
query getCustomerCheckId($customerId: ID!) {
customer(id: $customerId) {
metafield(namespace: "real_id", key: "check_id") {
value
}
}
}
```
On WooCommerce, the check ID is stored as [custom metadata](../woocommerce/metadata.md) under the `real_id_check_id` key on both the order and the user.
Read it in PHP with `get_user_meta` for the customer, or `$order->get_meta` for the order:
```php
get_meta( 'real_id_check_id' );
```
You can also view the order's `real_id_check_id` in the **Custom Fields** section of the order edit screen in WordPress admin.
On BigCommerce, the check ID is stored in the `realid.check_id` [metafield](../bigcommerce/metadata.md#realidcheck_id-metafield) on both the order and the customer.
Read it with the BigCommerce Metafields API:
```
GET /stores/{store_hash}/v3/orders/{order_id}/metafields
GET /stores/{store_hash}/v3/customers/{customer_id}/metafields
```
Filter by the `realid` namespace to get the check ID:
```json
{
"data": [
{
"namespace": "realid",
"key": "check_id",
"value": "abc123def456",
"permission_set": "read"
}
]
}
```
For custom integrations, store the `check.id` returned from the [create check response](#response) in your own database, associated with the customer or order record.
```javascript
const response = await axios.post(
"https://real-id.getverdict.com/api/v1/checks",
{ customer: { email: "customer@example.com" } },
{ headers: { Authorization: `Bearer ${yourApiKey}` } }
);
// Store this ID in your database for later retrieval
const checkId = response.data.check.id;
```
You can also listen for [webhook events](./webhooks.mdx) to be notified when the check status changes, and use the included `check.id` to update your records.
:::note
These fields are only present on customers and orders that have had an ID check created. If your trigger rules only require verification under specific conditions, customers or orders that don't match won't have a check ID to look up.
Creating a new ID check for the same customer or order will overwrite the stored check ID with the most recent one.
:::
### Parameters
Include additional data using query parameters. By default this endpoint returns all text based data. To access the photos submitted for the ID check, pass the `withPhotos` query parameter:
```
GET https://real-id.getverdict.com/api/v1/checks/{{checkId}}?withPhotos=true
```
The legacy 4 photos (`id`, `selfie`, `proofOfAddress`, `signature`) are returned as short-lived URLs under the `photos` key.
If the check carries multi-additional-documents (see [Multiple additional documents](#multiple-additional-documents) above), every entry in `additional_documents` is additionally decorated with a short-lived `photo_url` pointing at that doc's S3 object:
```json
{
"check": {
"additional_documents": [
{
"id": "ct-ammo-cert",
"title": "Connecticut Ammunition Certificate",
"photo_url": "https://real-id-uploads.s3.amazonaws.com/...",
"verdict": true
}
],
"photos": {
"id": "https://...",
"selfie": "https://...",
"proofOfAddress": null,
"signature": null
}
}
}
```
`photo_url` is `null` when the customer hasn't uploaded that doc yet.
### Example Response
```json
{
"check": {
"order": {
"id": null,
"name": null
},
"customer": {
"id": null,
"phone": null,
"email": "johnsmith@gmail.com"
},
"rules": {
"testing": true,
"signature_required": false,
"id_check_type": "idv",
"include_back_of_id": false
},
"result": {
"errors": [],
"signals": [],
"scores": {
"id": 0.9965,
"selfie": 0.9891,
"face_match": 0.8198
},
"document": {
"first_name": "TESTFIRSTNAME",
"last_name": "TESTFIRSTNAME",
"middle_name": null,
"verified_address": {
"unit": null,
"streetNumber": 1234,
"street": "Test St",
"country": "US",
"state": "OH",
"city": "Cleveland",
"postalCode": "44107"
},
"document_number": "15-239-1250",
"expiration_date": "04/24/2018",
"issue_date": "08/27/2015",
"birth_date": "06/14/1946",
"birth_date_iso": "1946-06-14T00:00:00.000Z",
"issuing_state": "CO",
"issuing_country": "US",
"type": "drivers-license"
}
},
"id": "abcedef123",
"step": "completed",
"shop_name": "real-id-dev.myshopify.com",
"created_at": "2022-12-09T15:20:35.136Z",
"platform": "shopify"
}
}
```
:::tip Birth Date Formats
The API response includes two formats for the birth date:
- `birth_date` - Original MM/DD/YYYY format (e.g., "06/14/1946")
- `birth_date_iso` - ISO 8601 format (e.g., "1946-06-14T00:00:00.000Z")
The `birth_date_iso` field provides a standardized date format for easier integration with modern systems. This field may be `null` if the birth date could not be extracted or for older checks that haven't been reprocessed.
:::
#### Using the response
With this response, you can craft the customer's ID check link for use within your own app to link the customer to their ID check.
The response's `check.id` field is the unique token for this ID check. You can append it to our hosting link to start the customer's ID check session:
```
https://idv.link/{{checkId}}
```
In our example response above, the unique check ID is `abcedef123`, so the link for this ID check sesison would be: `https://idv.link/abcedef123`.
:::danger Downloading not recommended
Real ID securely stores customer PII data on your behalf. While you can access this data over the REST API securely, we highly recommend _not_ downloading photos or customer data.
You will be responsible for maintaining secure access to this data, as well as fulfilling all legal retrieval and data deletion requests on the downloaded copies.
:::
## Delete ID check data
Real ID gives you the control to delete a customer's ID check data completely.
```
DELETE https://real-id.getverdict.com/api/v1/checks/{{checkId}}
```
:::danger
**This is an irreversible action.**
The ID check records and corresponding images will be deleted immediately.
:::
### Parameters
No parameters are required.
### Example Response
```json
{
"message": "Check deleted.",
"check": {
"id": "abcedef"
}
}
```
:::info
Not all customer data can be deleted synchronously. All traces of customer data will be deleted within 30 days.
:::
---
// File: api/webhooks
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# Webhooks
Real ID will emit webhooks in real time throughout the ID verification lifecycle.
Use these webhooks to synchronize your customer data with their current ID check status, or to hold and release orders by verified customers.
:::note
This feature is for **Protect** and above subscribers only.
:::
## ID check events
Real ID will emit HTTP webhooks during the following events:
- `check.delivered` - the ID check is initially created.
- `check.opened` - the customer opens the ID check.
- `check.submitted-photo` - the ID check receives a photo from the customer.
- `check.completed` - the customer successfully completes the ID check.
- `check.failed` - the customer fails the ID check.
### Check Event Data
Webhooks are sent as `POST` requests and include a JSON body. Below is an example of a `check.created` event:
```json
{
"event": "check.created",
"created_at": "2022-12-09T15:20:35.136Z",
"check": {
"id": "abcdef",
"step": "delivered",
"testing": true
}
}
```
### Status changes
Below is a state diagram that illustrates how the ID check statuses change through the ID check lifecycle:
```mermaid
flowchart TD
triggered(Automatic ID check triggered or manually sent) -- ID check delivered to the customer --> delivered
delivered([check.delivered]) -- Customer opens ID check --> opened([check.opened])
opened -. Customer submits one or more photos .-> submitted_photos([check.submitted_photos])
submitted_photos -. Customer submits selfie .-> submitted_photos
submitted_photos -. All required photos captured .-> id_check_processed{ID verification}
id_check_processed -. Customer fails ID check .-> id_check_failed([check.failed])
id_check_processed -. Customer passed ID check .-> id_check_passed([check.passed])
id_check_failed -. Staff member overrides results .-> id_check_passed
id_check_passed -. Staff member overrides results .-> id_check_failed
```
:::note
Some steps will affect with overall verdict even though more photos might be required and the check is in progress.
For example, if the customer's ID photo is missing required fields or is unreadable, then even if the face match passes, the overall ID check would be a failure.
:::
## Privacy events
Customers can contact Real ID directly regarding their ID checks. Real ID is a processor of your customer data, it does not act on these requests directly.
As a controller, you can subscribe to these webhooks for notifications on the following privacy related events:
- `customer.data_request` - A customer has requested a copy of all of their data.
- `customer.manual_review_requested` - A customer has requested a manual review of their ID check results.
- `customer.data_deletion_request` - A customer has requested to have their data deleted.
### Privacy Event Data
Webhooks are sent as `POST` requests and include a JSON body. Below is an example of a `customer.data_request` event:
```json
{
"event": "customer.data_request",
"created_at": "2022-12-09T15:20:35.136Z",
"check": {
"id": "abcdef",
"testing": true
}
}
```
:::tip
Use the included `check.id` in the response to query the full check data with the [retrieve a check API endpoint](/docs/api/checks#retrieve-an-id-check).
:::
## Defining Webhook URLs
Add the URL that should receive these events, then copy the signing secret you'll use to verify them. Both live in your store admin.
In the Real ID Shopify app, go to **Settings > DevTools > Webhooks**. Enter your webhook URL, turn webhooks on, and copy the **Signing secret**.
In the Real ID plugin, open **Settings > DevTools > Webhooks**. Enter your webhook URL, turn webhooks on, and copy the **Signing secret**.
You can send a test webhook from this section to confirm your endpoint is set up correctly.
All events contain the unique check ID, the event name, and the check data.
## Verifying Webhooks
The webhook HTTP request contains a `X-Real-ID-Signature` header that will need to be verified for authenticity.
Use your **Signing secret** from your store admin (**Settings > DevTools > Webhooks**) to sign the request's body to ensure that the request is originating from Real ID.
```js
const crypto = require("crypto");
function verifyWebhookSignature(payload, headers) {
// The signature included in the request headers
signature = headers["x-real-id-signature"];
// The webhook private signing key you can find within the Real ID app settings
secret_key = process.env.REAL_ID_SIGNING_KEY;
// Compute the HMAC signature using the provided secret key and payload
const computedSignature = crypto
.createHmac("sha256", secretKey)
.update(JSON.stringify(payload))
.digest("hex");
// Compare the computed signature with the one included in the request headers
if (computedSignature === signature) {
console.log("Webhook signature is valid");
} else {
console.log("Webhook signature is invalid");
}
}
```
```py
import os
import hmac
import hashlib
import json
def verify_webhook(body, headers):
# NOTE: by default, Python's json.dumps returns additional pretty printing that will introduce whitespace not included during generation
# Remove extra whitespace if using json.dumps as the payload body
# If you're using Flask, use the `request.get_data()` method to retrieve the raw body
payload = json.dumps(body, separators=(',', ':'))
# The signature included in the request headers
signature = headers["x-real-id-signature"]
# The webhook private signing key you can find within the Real ID app settings
secret_key = os.environ.get('REAL_ID_SIGNING_KEY')
# Compute the HMAC signature using the provided secret key and payload
computed_signature = hmac.new(
key=bytes(secret_key, 'utf-8'),
msg=bytes(payload, 'utf-8'),
digestmod=hashlib.sha256
).hexdigest()
# Compare the computed signature with the one included in the request headers
if computed_signature == signature:
return True
else:
return False
```
The shape of data is the same across the other events, only the `event` and the `check.step` will change from event type to event type.
:::warning
For security purposes, not all data associated with the ID check is included in the webhook.
To retrieve all details, [make a request to the `GET check` API endpoint](/docs/api/checks#retrieve-an-id-check) with the unique check ID included.
:::
## Allowlisting Real ID's IP address
Real ID sends all webhooks from a single, dedicated static IP address:
```
100.51.45.70
```
If your endpoint sits behind a firewall, WAF, or security plugin that filters inbound traffic by IP, add `100.51.45.70` to its allowlist so our webhooks aren't blocked.
:::info
This one IP covers every webhook Real ID sends — the `check.*` and `customer.*` events described above, as well as the order and customer metadata updates Real ID sends back to WooCommerce stores. You only need to allowlist this single address.
:::
All requests originate from the AWS `us-east-1` region. The address is stable and is not expected to change; we'll notify subscribers in advance if it ever does.
---
// File: bigcommerce/after-checkout
# After Checkout Verification
After checkout verification allows customers to complete their order first, then verify their ID on the order confirmation page. This is the recommended approach for most stores.
## How it works
1. Customer shops and completes checkout normally
2. On the order confirmation page, they see the ID verification prompt
3. Customer uploads their ID and completes verification
4. Order is held until verification is complete
## Setup
### Step 1: Install the Real ID App
1. Visit the [Real ID app listing](https://www.bigcommerce.com/apps/real-id/) in the BigCommerce App Marketplace
2. Click **Install** and authorize the app for your store
3. You'll be redirected to the Real ID dashboard
### Step 2: Configure After Checkout Flow
1. In the Real ID dashboard, go to **Settings** > **Automations**
2. Enable **Automated ID checks**
3. Select **After checkout** as your verification flow (this is the default)
4. Configure your trigger rules (see Built-in Triggers below)
5. Click **Save**
That's it! The Real ID verification script is automatically installed on your order confirmation page.
## Built-in Triggers
Configure which orders should trigger ID verification. These options require no code - just toggle them on in the Real ID dashboard.
### Check all orders
Require ID verification for every order. When enabled, all other trigger rules are ignored.
### Order value threshold
Require ID verification only for orders above a certain amount. Set your minimum order value (e.g., $100) and only high-value orders will require verification.
### Address mismatch
Require ID verification when the shipping and billing addresses don't match. This is a common fraud indicator and helps verify the customer's identity when there's a discrepancy.
### Product categories
Require ID verification for orders containing products from specific categories. Select which product categories should trigger verification - useful for age-restricted items like alcohol, tobacco, or firearms.
### U.S. shipping states
Require ID verification only for orders shipping to the United States. You can further narrow this to specific states - useful for complying with state-specific regulations.
:::tip Combining Triggers
When multiple triggers are enabled, verification is required if **any** rule matches. For example, if you enable both "Order value threshold ($100)" and "Address mismatch", a $50 order with mismatched addresses OR a $150 order with matching addresses will both require verification.
:::
## Order status filtering
Before evaluating your trigger rules, Real ID automatically filters out orders based on their BigCommerce order status. This ensures ID verification is only triggered for orders that are actually going to be fulfilled.
### Unpaid orders
Orders in these statuses are skipped because payment hasn't been completed yet:
| Status | Status ID | Why it's skipped |
|--------|-----------|------------------|
| **Incomplete** | 0 | Customer started checkout but hasn't completed payment |
| **Awaiting Payment** | 7 | Order placed but payment is still pending |
When an order transitions from an unpaid status to a paid status (e.g., from "Incomplete" to "Awaiting Fulfillment"), Real ID will automatically evaluate your triggers and create an ID check if needed.
### Terminal orders
Orders in these statuses are skipped because they will never be fulfilled:
| Status | Status ID | Why it's skipped |
|--------|-----------|------------------|
| **Cancelled** | 5 | Order was cancelled by merchant or customer |
| **Declined** | 6 | Payment was declined or order was rejected for fraud |
| **Completed** | 10 | Order has already been fulfilled and delivered |
:::info This filtering is automatic
These status filters are built into Real ID and cannot be customized. They run before your trigger rules are evaluated, ensuring you don't waste ID checks on orders that won't be shipped.
:::
## Customer experience
When after checkout verification is enabled:
- Customers complete their purchase normally
- The verification prompt appears on the order confirmation page
- Customers can verify immediately or return later via email link
- Already-verified customers are recognized automatically
## Frequently Asked Questions
### What happens if a customer doesn't complete verification?
The order remains in your system but is flagged as pending verification. You can configure automatic reminder emails to prompt customers to complete their verification.
### Can I customize when verification is required?
Yes! Use the built-in triggers above to configure rules based on order value, address mismatch, specific product categories, or customer location. For more complex conditions, see the Custom Trigger Scripts section below.
### What if a customer closes the page before verifying?
Real ID automatically sends an email with a link to complete verification. You can also configure automatic reminders.
### Do returning customers need to verify again?
No. Real ID remembers verified customers. When they return and place another order, they're automatically recognized and won't need to verify again.
## Custom Trigger Scripts
For merchants who need custom trigger logic beyond the built-in options, you can create scripts that conditionally trigger ID verification using the Real ID JS SDK based on order details.
:::info SDK and Order Data Already Loaded
The Real ID SDK and order data are automatically loaded on your order confirmation page when you enable after checkout verification. You only need to add a custom script with your trigger logic - no need to add the SDK or modify your theme.
:::
### How Custom Triggers Work
1. Your custom script fetches order details using the BigCommerce Storefront API
2. If conditions are met, your script calls `RealID.createFlow()` to trigger verification
3. The SDK handles the rest - displaying the verification UI and processing the result
### Adding a Custom Trigger Script
1. In BigCommerce admin, go to **Storefront** > **Script Manager**
2. Click **Create a Script**
3. Fill in the following:
- **Name**: Real ID Custom Trigger
- **Description**: Custom ID verification trigger
- **Location on page**: Footer
- **Select pages where script will be added**: Order Confirmation
- **Script category**: Essential
- **Script type**: Script
4. Paste one of the example scripts below
5. Click **Save**
:::tip Using the Store Hash
The order confirmation page already has the store hash available via `window.realIdOrderData.store_hash` (set automatically by the Real ID app). The examples below use this value directly.
:::
### Example 1: Specific State AND Product Category (Combined)
Trigger verification only when BOTH conditions are met: shipped to California AND order contains products from specific categories.
```html
```
:::tip Finding Category IDs
To find your category IDs, go to **Products** > **Product Categories** in your BigCommerce admin. Click on a category - the ID is shown in the URL (e.g., `/manage/categories/23` means the ID is `23`).
:::
### Example 2: Specific State AND Custom Field (Combined)
Trigger verification only when BOTH conditions are met: shipped to California AND order contains products with the `id_verification_required` custom field.
```html
```
:::tip Creating Custom Fields
To add a custom field to a product:
1. Go to **Products** > **View** in BigCommerce admin
2. Edit the product
3. Scroll to **Custom Fields**
4. Add a field with name `id_verification_required` and value `true`
5. Save the product
:::
:::tip Combining Conditions
These examples demonstrate AND logic - both conditions must be true. You can adapt this pattern to combine any conditions:
- Change `REQUIRED_STATE` to any US state code (e.g., 'NY', 'TX')
- Add multiple states by changing the check to `['CA', 'NY'].includes(stateCode)`
- Combine with order total checks by adding `order.orderAmount >= MINIMUM_AMOUNT`
:::
### Learn More
For more information about the Real ID JS SDK, including theming options and prepopulating customer data, see our [JavaScript SDK documentation](../js).
---
// File: bigcommerce/before-checkout
# Before Checkout Verification
Before checkout verification requires customers to verify their ID before they can complete their purchase. This prevents orders from unverified customers entirely.
## How it works
1. Customer adds items to cart and proceeds to checkout
2. Before they can enter payment information, the ID verification prompt appears
3. Customer must complete verification to continue
4. Once verified, they can complete their purchase
## Setup
### Step 1: Install the Real ID App
1. Visit the [Real ID app listing](https://www.bigcommerce.com/apps/real-id/) in the BigCommerce App Marketplace
2. Click **Install** and authorize the app for your store
3. You'll be redirected to the Real ID dashboard
### Step 2: Configure Before Checkout Flow
1. In the Real ID dashboard, go to **Settings** > **Automations**
2. Enable **Automated ID checks**
3. Select **Before checkout** as your verification flow
4. Configure your trigger rules (see Built-in Triggers below)
5. Click **Save**
That's it! The Real ID verification script is automatically installed on your checkout page.
## Built-in Triggers
Configure which customers should be prompted for ID verification. These options require no code - just toggle them on in the Real ID dashboard.
### Verify all orders
Require ID verification for every checkout. When enabled, all other trigger rules are ignored.
### Cart value threshold
Require ID verification only for carts above a certain amount. Set your minimum cart value (e.g., $100) and only high-value orders will require verification.
### Product categories
Require ID verification for carts containing products from specific categories. Select which product categories should trigger verification - useful for age-restricted items like alcohol, tobacco, or firearms.
### U.S. shipping states
Require ID verification only for orders shipping to the United States. You can further narrow this to specific states - useful for complying with state-specific regulations.
:::tip Combining Triggers
When multiple triggers are enabled, verification is required if **any** rule matches. For example, if you enable both "Cart value threshold ($100)" and "Product categories (Alcohol)", a $50 order with alcohol OR a $150 order without alcohol will both require verification.
:::
## Customer experience
When before checkout verification is enabled:
- Customers shop and add items to cart normally
- When they proceed to checkout, the verification prompt appears
- They must complete ID verification before entering payment details
- Already-verified customers skip the verification step automatically
## Frequently Asked Questions
### Will this slow down checkout for all customers?
No. Real ID remembers verified customers. Returning customers who have already verified their ID will proceed directly to checkout without seeing the verification prompt again.
### Can I require verification only for certain products or orders?
Yes! Use the built-in triggers above to configure rules based on order value, specific product categories, or customer location. For more complex conditions, see the Custom Trigger Scripts section below.
### What if a customer can't complete verification?
If a customer is unable to verify their ID, they won't be able to complete checkout. You can review failed verification attempts in your Real ID dashboard and contact the customer if needed.
### Is this compatible with all BigCommerce themes?
Before checkout verification works with most BigCommerce themes. If you experience any display issues, please [contact our support team](https://getverdict.com/contact).
### Can customers save their cart and verify later?
Yes. If a customer leaves during verification, their cart is preserved. When they return and try to checkout again, they'll be prompted to complete verification.
## Custom Trigger Scripts
For merchants who need custom trigger logic beyond the built-in options, you can create scripts that conditionally trigger ID verification using the Real ID JS SDK.
:::info SDK Already Loaded
The Real ID SDK is automatically loaded on your checkout page when you enable before checkout verification. You only need to add a custom script with your trigger logic - no need to add the SDK separately.
:::
### How Custom Triggers Work
1. Your custom script evaluates conditions using BigCommerce Storefront APIs
2. If conditions are met, your script calls `RealID.createFlow()` to trigger verification
3. The SDK handles the rest - displaying the verification UI and processing the result
### Adding a Custom Trigger Script
1. In BigCommerce admin, go to **Storefront** > **Script Manager**
2. Click **Create a Script**
3. Fill in the following:
- **Name**: Real ID Custom Trigger
- **Description**: Custom ID verification trigger
- **Location on page**: Footer
- **Select pages where script will be added**: Checkout
- **Script category**: Essential
- **Script type**: Script
4. Paste one of the example scripts below
5. Click **Save**
:::info Multi-step Checkout
BigCommerce uses a multi-step checkout where elements appear dynamically. The examples below include a `waitForSelector` helper function that waits for the "Place Order" button to appear before triggering verification.
:::
:::tip Finding Your Store Hash
Each example requires your BigCommerce **store hash** - a unique identifier for your store. You can find it in:
- Your BigCommerce admin URL: `https://store-{STORE_HASH}.mybigcommerce.com/manage/...`
- Example: If your URL is `store-abc123xyz.mybigcommerce.com`, your store hash is `abc123xyz`
Replace `YOUR_STORE_HASH` in the examples below with your actual store hash.
:::
### Example 1: Specific State AND Product Category (Combined)
Trigger verification only when BOTH conditions are met: shipping to California AND cart contains products from specific categories.
```html
```
:::tip Finding Category IDs
To find your category IDs, go to **Products** > **Product Categories** in your BigCommerce admin. Click on a category - the ID is shown in the URL (e.g., `/manage/categories/23` means the ID is `23`).
:::
### Example 2: Specific State AND Custom Field (Combined)
Trigger verification only when BOTH conditions are met: shipping to California AND cart contains products with the `id_verification_required` custom field.
```html
```
:::tip Creating Custom Fields
To add a custom field to a product:
1. Go to **Products** > **View** in BigCommerce admin
2. Edit the product
3. Scroll to **Custom Fields**
4. Add a field with name `id_verification_required` and value `true`
5. Save the product
:::
:::tip Combining Conditions
These examples demonstrate AND logic - both conditions must be true. You can adapt this pattern to combine any conditions:
- Change `REQUIRED_STATE` to any US state code (e.g., 'NY', 'TX')
- Add multiple states by changing the check to `['CA', 'NY'].includes(shippingAddress.stateOrProvinceCode)`
- Combine with cart total checks by adding `cart.cartAmount >= MINIMUM_AMOUNT`
:::
### Learn More
For more information about the Real ID JS SDK, including theming options and prepopulating customer data, see our [JavaScript SDK documentation](../js).
---
// File: bigcommerce/billing
# Billing & Subscription
Real ID for BigCommerce uses Stripe for billing, integrated directly within the app. You can manage your entire subscription from the Billing tab in the Real ID settings without needing a separate account.
## Subscribing to a Plan
To subscribe to Real ID:
1. Open the **Real ID** app in your BigCommerce admin
2. Go to **Settings** → **Billing** tab
3. Select a plan from the pricing options displayed
4. Complete the checkout process with your payment details
Once subscribed, you'll have immediate access to all Real ID features included in your plan.
For current pricing details, visit our [pricing page](https://getverdict.com/pricing).
## Viewing Your Current Plan
To view your subscription details:
1. Open the **Real ID** app in your BigCommerce admin
2. Go to **Settings** → **Billing** tab
Here you'll see:
- **Current plan** — Your active subscription plan and status
- **Billing cycle** — Whether you're on monthly or annual billing
- **Next billing date** — When your next payment will be processed
- **Usage this period** — Number of ID checks used in the current billing cycle
## Managing Your Subscription
All subscription management is handled through the Stripe customer portal. To access it:
1. Open the **Real ID** app in your BigCommerce admin
2. Go to **Settings** → **Billing** tab
3. Click the **Manage Subscription** button
This opens the Stripe customer portal where you can:
- **View invoices** — See your complete billing history
- **Update payment method** — Change your credit card or payment details
- **Change plan** — Upgrade or downgrade your subscription
- **Cancel subscription** — End your Real ID subscription
### Quick Actions
The Billing tab also provides quick action buttons for common tasks:
- **View Invoices** — Opens the Stripe portal to your invoice history
- **Update Payment Method** — Jump directly to payment settings
- **Change Plan** — Modify your current subscription
## Canceling Your Subscription
To cancel your Real ID subscription:
1. Open the **Real ID** app in your BigCommerce admin
2. Go to **Settings** → **Billing** tab
3. Click **Manage Subscription**
4. In the Stripe portal, click **Cancel plan** or **Cancel subscription**
5. Confirm the cancellation
:::warning Before You Cancel
Make sure to download any ID check photos or data you need before canceling. See [Downloading Customer Photos](../for-merchants/downloading-customer-photos.md) for instructions.
:::
### What Happens After Cancellation
When you cancel your subscription:
- **Access until period end** — You'll retain access to Real ID until your current billing period ends
- **No further charges** — You won't be charged after the current period
- **Data retention** — Your ID check data will be retained for 90 days after your subscription ends, then permanently deleted
If you see a message that your subscription will be canceled on a specific date, this confirms your cancellation is scheduled and you'll have access until that date.
### Resubscribing After Cancellation
If you want to use Real ID again after canceling:
1. Open the **Real ID** app in your BigCommerce admin
2. Go to **Settings** → **Billing** tab
3. Select a new plan and complete checkout
If you resubscribe within 90 days, your previous ID check data will still be available.
## Uninstalling the App
If you want to completely remove Real ID from your BigCommerce store:
1. Go to **Apps** → **My Apps** in your BigCommerce admin
2. Find **Real ID** in your installed apps
3. Click the **Uninstall** button
:::info Cancel First
We recommend canceling your subscription through the Billing tab before uninstalling. This ensures your subscription is properly terminated and you have a clear record of the cancellation.
:::
## Frequently Asked Questions
### How do I get a receipt or invoice?
1. Go to **Settings** → **Billing** in the Real ID app
2. Click **View Invoices** or **Manage Subscription**
3. Download invoices directly from the Stripe portal
### Can I switch between monthly and annual billing?
Yes. Click **Manage Subscription** in the Billing tab, then select a different billing interval in the Stripe portal.
### What payment methods are accepted?
Real ID accepts all major credit and debit cards through Stripe, including Visa, Mastercard, American Express, and Discover.
### Will canceling affect my existing orders?
No. Canceling Real ID will not modify, cancel, or refund any of your orders. ID verification will simply stop for new orders, and any existing ID check data will remain accessible until the 90-day retention period ends.
### Why am I seeing "No Active Subscription"?
If you see this message in the Billing tab, it means you don't currently have an active Real ID subscription. Select a plan to subscribe and start verifying IDs.
---
// File: bigcommerce/metadata
# Metafields
Real ID automatically syncs the status of your ID checks to BigCommerce orders and customers using metafields. It writes two metafields under the `realid` namespace:
- `realid.check_id` - the specific ID check associated with this customer or order
- `realid.verification_status` - the current status of the ID check
These metafields are updated automatically as customers progress through their ID verification.
## `realid.verification_status` Metafield
This metafield is present on both the order and the customer. It reflects the current state of the ID check and is kept in sync during the customer's ID verification lifecycle.
Here are all of the possible values:
- `pending` - the ID check has been created but the customer has not opened it yet
- `in_progress` - the customer has opened the ID check and is actively verifying
- `in_review` - the ID check has warnings (such as an expired ID) that require manual approval
- `failed` - the ID check failed conclusively
- `verified` - the customer successfully completed their ID check
- `manually_approved` - a staff member manually approved the ID check
- `manually_rejected` - a staff member manually rejected the ID check
:::note
These metafields will only be present on orders or customers that have an associated ID check. If you have trigger rules configured that only require ID verification under specific conditions, orders that don't match those conditions won't have these metafields.
:::
## `realid.check_id` Metafield
This metafield is present on both the order and the customer. It contains the unique token that references the customer's most recent ID check.
You can use this token as the ID parameter for [retrieving the details of the ID check with the Real ID REST API](../api/checks.mdx).
Manually creating new ID checks will overwrite the `realid.check_id` metafield. If the customer is already verified then a new ID check will replace the current value.
## Viewing Metafields
You can view the metafields for an order or customer through the BigCommerce API. Use the [BigCommerce Metafields API](https://developer.bigcommerce.com/docs/rest-management/customers/customer-metafields) to retrieve them programmatically.
### Order metafields
```
GET /stores/{store_hash}/v3/orders/{order_id}/metafields
```
### Customer metafields
```
GET /stores/{store_hash}/v3/customers/{customer_id}/metafields
```
### Example response
```json
{
"data": [
{
"namespace": "realid",
"key": "verification_status",
"value": "verified",
"permission_set": "read"
},
{
"namespace": "realid",
"key": "check_id",
"value": "abc123def456",
"permission_set": "read"
}
]
}
```
## How metafields are synchronized
Real ID sends updates to BigCommerce as customers progress through their ID check. Metafields are updated at each stage:
1. **Check created** - metafields are set to `pending`
2. **Customer opens the check** - status updates to `in_progress`
3. **Customer submits photos** - status remains `in_progress`
4. **Verification completes** - status updates to `verified` or `failed`
5. **Manual override** - status updates to `manually_approved` or `manually_rejected`
These updates are processed asynchronously, so there may be a brief delay between the customer's action and the metafield update appearing in BigCommerce.
---
// File: bigcommerce/order-statuses
# Order Status Syncing
Real ID can automatically update your BigCommerce order statuses based on the ID verification results. This helps you track which orders are waiting for verification, which have passed, and which have failed — all from your BigCommerce dashboard.
:::info Feature Must Be Enabled
Order status syncing is **disabled by default**. You'll need to enable it in your Real ID settings to start using this feature.
:::
## How it works
When a customer needs to verify their ID, Real ID can automatically update the order status at each step of the verification process:
```mermaid
flowchart TD
subgraph Your Store
A[Customer places order] --> B{ID verification required?}
B -- No --> C[Order proceeds normally]
B -- Yes --> D[Order status: Manual Verification Required]
end
subgraph ID Verification
D --> E[Customer receives ID check request]
E --> F{Customer completes verification}
F -- Passes --> G[Order status: Awaiting Fulfillment]
F -- Fails --> H[Order status: Declined]
end
subgraph Your Fulfillment
G --> I[Ship the order]
H --> J[Review & decide]
end
```
### Status flow explained
1. **Order placed** — Customer completes checkout
2. **Verification starts** — Order moves to your "in progress" status (default: Manual Verification Required)
3. **Customer submits ID** — Order stays in progress while being reviewed
4. **Verification completes**:
- ✅ **Passed** — Order moves to your "success" status (default: Awaiting Fulfillment)
- ❌ **Failed** — Order moves to your "failed" status (default: Declined)
## Setting up order status syncing
1. Open your Real ID app in BigCommerce
2. Go to **Settings**
3. Click the **Order Sync** tab
4. Toggle **Order status syncing** to enabled

### Choosing your order statuses
You can customize which BigCommerce order status is assigned at each stage:
| Verification Stage | Default Status | When it's applied |
| ------------------ | ---------------------------- | --------------------------------------------------------- |
| In Progress | Manual Verification Required | When the ID check starts or customer is submitting photos |
| Passed | Awaiting Fulfillment | When the customer successfully verifies their ID |
| Failed | Declined | When verification fails or is rejected |
:::tip Custom Order Statuses
If you've created custom order statuses in BigCommerce, they'll automatically appear in the dropdown options.
:::

## Order Protection
One of the most important features is **Order Protection**. This prevents Real ID from accidentally changing the status of orders that have already been processed.
### Why is this important?
Imagine this scenario:
1. Customer places an order and passes ID verification
2. You ship the order (status: **Shipped**)
3. Days later, something triggers the ID check to re-sync
4. Without protection, the order could move back to **Awaiting Fulfillment**
5. Your fulfillment team might accidentally ship it again! 📦📦
**Order Protection prevents this** by never changing orders that are already in certain "final" statuses.
```mermaid
flowchart LR
subgraph Protected Statuses
A[Shipped]
B[Cancelled]
C[Refunded]
D[Completed]
end
E[ID Verification Update] --> F{Is order in protected status?}
F -- Yes --> G[❌ Status NOT changed]
F -- No --> H[✅ Status updated]
```
### Default protected statuses
By default, Real ID will **not** change orders that are already:
- **Shipped** — Order has been shipped to the customer
- **Partially Shipped** — Some items have been shipped
- **Refunded** — Order has been refunded
- **Cancelled** — Order was cancelled
- **Completed** — Order is fully complete
- **Partially Refunded** — A partial refund was issued
### Customizing protected statuses
You can add or remove protected statuses in the **Order Protection** section of the Order Sync settings:
1. Go to **Settings** → **Order Sync**
2. Scroll to the **Order Protection** section
3. Check or uncheck statuses based on your workflow
:::caution Recommendation
We strongly recommend keeping **Shipped**, **Cancelled**, and **Refunded** as protected statuses to prevent fulfillment errors.
:::
## Understanding the status flow
Here's a complete picture of how order statuses flow through the ID verification process:
```mermaid
flowchart TD
A[New Order] --> B{Requires ID check?}
B -- No --> Z[Normal order flow]
B -- Yes --> C[Set to: In Progress status]
C --> D[Customer receives verification request]
D --> E[Customer opens link]
E --> F[Customer submits ID photos]
F --> G{Verification Result}
G -- Auto-approved --> H[Set to: Success status]
G -- Auto-rejected --> I[Set to: Failed status]
G -- Needs review --> J[Manual Review]
J --> K{Staff decision}
K -- Approve --> H
K -- Reject --> I
H --> L{Is order protected?}
I --> L
L -- Yes --> M[Status unchanged]
L -- No --> N[Status updated]
```
## Frequently Asked Questions
### Will enabling this feature cancel orders or issue refunds?
**No.** Real ID only changes the order status field. It does not cancel orders, issue refunds, or modify payment transactions in any way.
### What happens if I manually change an order's status?
Real ID will respect your manual changes. However, if the ID verification status changes later (for example, a staff member manually approves a failed check), Real ID may update the status again — unless the order is in a protected status.
### Can I use custom order statuses?
**Yes!** Any custom order statuses you've created in BigCommerce will automatically appear as options in the Real ID settings.
### What if an order is already shipped when verification completes?
If the order is in a **protected status** (like Shipped), Real ID will **not** change its status. The verification result will still be recorded in the order notes, but the status will remain unchanged.
### How do I know if an order's status was changed by Real ID?
Real ID adds a note to the order each time it processes an ID verification. You can view these notes in the order details within BigCommerce.
### Does this work with fulfillment apps like ShipStation?
Yes! The order status changes made by Real ID are standard BigCommerce status updates. Any app that reads order statuses (like ShipStation, ShipBob, etc.) will see the updated status.
:::tip Pro Tip
The default "Failed" status is **Declined**, which will prevent most fulfillment apps from shipping the order. If you prefer a different workflow, you can change this to **Manual Verification Required** or a custom "On Hold" status.
:::
## Troubleshooting
### Order status isn't changing
Check the following:
1. **Is order status syncing enabled?** Go to Settings → Order Sync and ensure the toggle is on.
2. **Is the order in a protected status?** Orders in protected statuses won't be updated.
3. **Is the order a BigCommerce order?** This feature only works with orders from your BigCommerce store.
### Order moved to wrong status
If an order was moved to an unexpected status:
1. Check if the ID verification result changed (view the check details in Real ID)
2. Review your status mapping in Settings → Order Sync
3. Consider adding that status to your protected list if needed
## Related Documentation
- [After Checkout Verification](./after-checkout.md) — Setting up ID verification after customers complete checkout
- [Before Checkout Verification](./before-checkout.md) — Requiring ID verification before customers can checkout
---
// File: bigcommerce/viewing-ids
# Viewing ID Checks
Real ID provides multiple ways to view and manage ID verification checks for your BigCommerce store.
- Inside the Real ID App
- From the BigCommerce orders dashboard
- From the BigCommerce customers dashboard
## From the Real ID App
The primary way to view all ID checks is through the Real ID app dashboard.
### Accessing the Dashboard

1. Log in to your BigCommerce admin panel
2. Navigate to **Apps** > **Real ID**
3. Click on **ID Checks** in the navigation
### Dashboard Features

The ID Checks dashboard provides:
- **List View**: See all ID checks with status, customer name, order number, and date
- **Filtering**: Filter by status (Verified, Failed, In Progress, In Review)
- **Search**: Search by customer name, email, or order number
- **Bulk Actions**: Archive or unarchive multiple checks at once
### Check Details Page
Click on any ID check to view its full details:
- Customer information (name, email, phone)
- Verification status and confidence scores
- Submitted photos (ID front/back, selfie, signature)
- Document details extracted from the ID (name, DOB, expiration)
- Timeline of events (when sent, opened, submitted, verified)
- Actions (approve, reject, send reminder, archive)
## From Order Details

Real ID adds an **ID Verification** panel directly to your BigCommerce order pages, allowing you to view verification status without leaving the order context.
### How It Works

When viewing an order in your BigCommerce admin, you'll see an "ID Verification" menu item in the order actions. Clicking it opens a side panel with:
- **Customer Info**: Name, email, and order number
- **Verification Status**: Current status badge (Verified, In Progress, Failed, etc.)
- **Confidence Score**: Overall verification confidence percentage
- **Submitted Photos**: Thumbnails of ID and selfie photos
- **Quick Actions**: Approve, reject, or send reminder buttons
- **Copy Link**: Copy the verification link to share with the customer
### Empty State
If the order doesn't have an associated ID check, the panel displays a quick form to create one. The form is pre-populated with the customer's information from the order, allowing you to send a verification request immediately.
### Navigating to Full Details
Click **View Full Details** in the panel to open the complete check details page in the Real ID app.

## From Customer Details
Similar to orders, Real ID adds an **ID Verification** panel to BigCommerce customer pages, showing the customer's verification history.
### Customer Panel Features
The customer panel shows:
- **Verification Status**: Whether the customer is verified or not
- **Customer Info**: Name and email from their most recent check
- **Latest ID Check**: The most recent verification with status and confidence score
- **Verification History**: A list of all ID checks for this customer
### Creating a Check for a Customer
If the customer has no verification history, the panel displays a form to create a new ID check pre-populated with the customer's information.
This is useful for:
- Proactively verifying customers before they place orders
- Re-verifying customers whose previous verification expired
- Verifying customers for non-order-related purposes
:::info REST API available
For developers and advanced integrations, you can retrieve ID checks programmatically using the Real ID REST API.
See the [REST API documentation](/docs/api/authentication) for details on authentication and available endpoints.
:::
## Summary
| Method | Best For |
| ------------------ | --------------------------------------------------- |
| **Real ID App** | Full management, bulk operations, detailed analysis |
| **Order Panel** | Quick status checks while processing orders |
| **Customer Panel** | Viewing customer verification history |
| **REST API** | Custom integrations, automation, reporting |
---
// File: delivering-id-checks
# Delivering ID checks
Real ID offers several ways to deliver ID checks to your customers. The right method depends on your verification flow and how you interact with your customers.
## Email and SMS
The most common delivery method. When an ID check is created — either [manually](./sending-an-id-check.md) or [automatically](./flows/after-checkout.mdx) — Real ID sends the customer a unique link to complete their verification via email and/or SMS.
You can customize the sender address, email content, and SMS messages in your [Theming](./theming/branding.md) settings.
If a customer doesn't complete their check right away, Real ID can send [automatic reminders](./for-merchants/automatic-id-check-reminders.md) to follow up.
## Embedded in your store
For a seamless experience, Real ID can embed the verification flow directly into your storefront — no separate link required. Depending on your needs, you can embed verification:
- **[After checkout](./flows/after-checkout.mdx)** — on the order confirmation page
- **[During checkout](./flows/during-checkout.md)** — within the checkout flow itself
- **[Before checkout](./flows/before-checkout.mdx)** — before customers can complete a purchase
- **[Before viewing your store](./flows/before-viewing-store.md)** — as a gate before browsing
- **[After account registration](./flows/after-registration.md)** — when a new account is created
These embedded flows still send email/SMS as a fallback if the customer navigates away before completing verification.
## Hosted links
Every ID check has a unique hosted link that you can share directly with customers:
```
https://verify.getverdict.com/{{checkId}}
```
This is useful when you want to deliver verification links through your own channels — like a custom email template, a chat message, or an in-app notification.
You can generate hosted links by [creating checks via the REST API](/docs/api/checks) with `deliver_check` set to `false` to suppress Real ID's built-in email/SMS, then send the link yourself.
### Email lookup links
If you don't have the check ID readily available, you can link customers to the hosted flow with just their email address:
```
https://verify.getverdict.com/?email=customer@example.com
```
When a customer visits this link, Real ID automatically looks up their pending ID check by email and redirects them to it. If no check is found, the customer is shown a form where they can search by email manually.
This is useful when you want to send customers a verification link but don't want to store or template the check ID — for example, in a generic follow-up email or a shared support link.
## JavaScript SDK
For full programmatic control, you can use the [JavaScript SDK](./js.mdx) to mount the verification flow anywhere on your site and control when and how it appears.
The SDK is ideal for custom integrations where you need to trigger verification based on your own application logic rather than Real ID's built-in triggers.
---
// File: faqs
# Frequently asked questions
Don't see an answer to your question? [Please ask us!](https://getverdict.com/contact)
## How does it work?
Real ID uses computer vision and A.I. technologies to identify the authenticity of your customer's IDs based on several proprietary models.
Your customers are sent a unique URL to their mobile device by email or SMS. This link opens a secure connection to allow the customer to upload a photo of their ID.
Once we receive the image, our combination of OCR (optical recognition technology), and A.I. models will score the photos. If the score of confidence is above your accepted threshold, as well as pass any additional rules set up for your account, the overall result is considered a "pass".
:::info
While Real ID is designed to help verify that a user is physically present in front of a camera with a valid ID and detect spoof attacks, including those presented via images or videos, it's not infallible and may not detect all spoof attempts.
Real ID provides a score of confidence of the likelihood of a valid ID and biometrics, with a pass or fail overall result based on a confidence threshold controlled by you and your staff within the app.
:::
## What kind of ID documents can Real ID recognize?
Real ID supports dozens of ID documents from hundreds of different countries. Supported documents include:
- Driver's Licenses
- Passports
- Residence Cards
- Commercially and nationally issued Health Insurance Cards
- Concealed Carry Licenses
[Please see our supported documents page](https://getverdict.com/supported-id-documents) for a full list of all documents that Real ID can instantly recognize.
Don't see the card or country you need to verify? Let us know. We'd be happy to help.
## How long does verification take?
The entire process can be completed in less than 30 seconds, assuming you have your ID on hand.
Real ID is built for eCommerce specifically, where speed is paramount especially if ID verification is required [before](./flows/before-checkout.mdx) or [during](./flows/during-checkout.md) checkout.
:::note
Real ID gives you and your team the ability to [override ID verification results](./for-merchants/overridding-results.md) at any time as well.
:::
## How can I tell when a customer has completed or failed ID verification?
On Shopify, Real ID will automatically leave [tags on customers and orders during the ID verification process](./shopify/tags.md). It will also [update metafields on customers and orders](./shopify/metafields.md) as well to allow theme customizations in liquid depending on the customer's verification status.
On WooCommerce, Real ID will automatically update the [customer's and order's meta as they progress through verification](./woocommerce/metadata.md). Real ID will also create an **ID verification** column in your orders page for easy reference.
## I don't want Real ID to send any ID checks automatically, can I choose which orders have ID verification?
Yes, all triggers are completely optional.
If you prefer to manually send out ID checks, just open the New ID Check page and select or manually type in the customer and their order.
## Why would I want my customer to submit a headshot with their ID photo?
Real ID gives you the choice to enable facial recognition scanning in addition to the ID document photo.
It's an option for higher risk transactions to protect against the possibility of using a physically stolen ID. By requiring a headshot of the ID document owner with the ID document, we can verify the photos match.
For example, even if a bad actor had possession of a stolen credit card and matching license - they would not be able to trick face matching to identify them.
It also helps prevent fraudulent chargebacks (a.k.a. "friendly fraud") by giving you even more hard evidence showing the customer intended to make the purchase.
## How are the IDs and photos secured?
Real ID encrypts the connection from your customers mobile devices. This protects their data from being intercepted by bad actors.
You don't have to think about compliance, Real ID stores your customers' data securely in our database in transit and at rest, and not on your own infrastructure.
You're always in control over what data you'd like to keep. [Delete your customer's ID or headshot photos at any time](./for-merchants/deleting-data.md) in the app.
## Are ID photos & data stored on my Shopify or WooCommerce store?
No, all customer data including photos & extracted details from the IDs are stored on Real ID's secure cloud. No PII (Personally Identifable Data) data is stored on your Shopify or WooCommerce store whatsoever. The only data stored on your store directly are the ID check statuses of each check, and the unique token that represents the customer's ID check. Please see the [tags](./shopify/tags.md), [metafields](./shopify/metafields.md), [notes](./shopify/notes.md) & [metadata](./woocommerce/metadata.md) to understand what this data looks like.
When viewing ID data in the Real ID dashboard, you're only viewing short lived photos that are directly from the Real ID secure cloud, and not from Shopify or WooCommerce. Please see our [Security & Privacy](https://getverdict.com/security-and-privacy) policies for more details.
You can also [restrict ID check access to specific staff members](./for-merchants/managing-staff-permissions.md) by limiting the permissions of who can view ID check data.
## If I receive a chargeback can I have a detailed report of an ID check for the dispute?
Yes, of course. Please [contact us](mailto:support@getverdict.com) if you have a chargeback from a customer with an ID verified by Real ID.
Chargebacks from ID verified orders are extremely rare. ID verification alone is a strong deterrent for both real and fraudulent chargebacks.
In the unlikely event you'll still receive a chargeback from an ID verified customer, we'll generate a detailed report for you to include in your evidence for the chargeback dispute.
:::tip
If your store is especially targeted by real or fraudulent chargebacks, we highly recommend [enabling biometric (selfie) verification](./id-check-process.md#face-match). Additionally you can also [enable Proof of Address documentation](./rules/proof-of-address.md) as part of the customer ID check for additional evidence.
:::
## Why are customers sent a link to a site `idv.link`?
`idv.link` is a shortened link for customers to submit their ID photos to. This shortened URL is designed specifically for SMS messages, because of the short character limit per message.
`idv.link` is associated with Real ID, it's just the default link for ID checks.
:::tip White labeling available
These links can be customized to match your website. For example, Real ID could verify your customers IDs at `verify.yoursite.com`, please [contact us](https://getverdict.com/contact) to get assistance setting up a white labeled link for better association with your brand.
:::
## How much does it cost?
We offer several different plans to meet your needs. See the [pricing page](https://getverdict.com/pricing) for more details.
There are two parts to each plan, the monthly fee and the usage fees.
The monthly fee is a base flat amount that doesn't change from month to month. The usage fees are incurred per ID check.
The higher monthly plans unlock more features, as well as reduce the per ID check usage fees.
Both fees are listed for each plan on the [pricing page](https://getverdict.com/pricing).
## Can I get a refund on completed or in progress ID checks?
Once a customer has submitted at least one photo for the ID check, it becomes non-refundable.
This still applies if the customer's photos are deleted after they've been submitted in the app.
## My customer says they can't open their ID check. What should I do?
We're happy to troubleshoot. Please contact us, or email us or chat with us in-app for support.
## Can I get a refund on my monthly subscription fee?
We cannot refund monthly subscriptions outside of a billing period (30) window.
## Can I delete my customers photos after they have been verified?
Protecting your customers privacy is very important to us. That's why we offer an option in any ID check to delete your customer's photos safely and permanently.
You can reassure your customers that their IDs will be wiped after they've verified their ID.
## What kind of information can I see in the dashboard?
Real ID automatically reads the text on any given document. Depending on the level of detail the document provides you can expect to read data such as:
- First Name
- Last Name
- Address
- Age
- City
- State
- Issuing Country of the ID
- Issuing State of the ID
- Unique License or Document ID
Additionally you can use these pieces of information to verify that the customer is qualified for the purchase. Or that their billing & shipping information matches their ID.
## Can I automatically require ID verification only on high risk orders?
Real ID offers a "sit and forget" customer verification process so you can require ID verification automatically on high risk orders.
You can enable rules to automatically trigger ID verification checks to your customers.
Total Order Price - depending on the amount of the total price of the order, you can trigger an ID check.
Mistmatching Shipping to Billing Address - if an order's shipping and billing address do not match, it's a sign of potential credit card fraud. Real ID can automatically verify these orders.
High risk - if an order is detected as medium or high risk by Shopify or other 3rd party anti-fraud apps, trigger an ID verification check.
And many more options. Learn more here.
## When is an ID check charged for?
ID checks are charged when the customer submits an ID photo and that ID is processed. The final automatic decision does not affect the charge.
If you have sent an ID check by mistake, you can approve or reject it manually to prevent the customer from uploading photos and incurring a charge.
If you have remember repeat customers enabled, then only ID checks will be sent to customers without the `ID verification completed` or `ID check manually approved` tag.
:::tip
To help prevent bad quality photos and failed checks, the customer must pass the [ID and selfie autocapture](./id-check-process#autocapturing-id-photos-and-headshots). This helps guide the customer to taking a quality in focus photo of their ID.
:::
## If I turn on automatic ID checking, will repeat customers receive ID checks twice?
There's an additional setting in the dashboard that allows you to only require ID verification once from your repeat customers.
That way you can reduce friction even further and keep your trusted customers from having to do multiple ID checks.
## I need to require my customer's signature for orders in addition to ID verification - can Real ID help?
Yes, easy & intuitive electronic signatures are available in Real ID. You can enable signature captures for ID verification checks. You'll be able to view and download your customers signatures right in the dashboard.
No code required to turn on or disable this feature.
---
// File: flows/after-checkout
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# ID verification after checkout

If you have one or more automatic ID verification rules enabled, on qualified orders Real ID will automatically prompt your customer to complete their ID verification via a unique link sent over email or SMS.
However, to make ID verification even more seamless and intuitive for your customers, you can enable Real ID to collect your customer's ID within your native checkout flow.
:::tip
We recommend this ID verification flow if possible. It's the most flexible and is the least amount of friction for your customers to finish their buying journey.
However, if your compliance requires ID verification [before checkout](./before-checkout.mdx), [during checkout](./during-checkout.md), or [before customers can view your store](before-viewing-store.md), we have options for you.
**Using BigCommerce?** See our [BigCommerce After Checkout guide](../bigcommerce/after-checkout.md) for platform-specific setup instructions.
:::
## Getting Started
Your automatic ID verification settings can be found under the **Automations** section of the **Settings** page:

To enable automatic ID verification, click the checkbox next to **Enable automated ID checks**, then select the **After Checkout** option:

After choosing the after checkout ID verification flow, click **Save** to apply the change.
Real ID will automatically embed the ID verification flow within your store's order confirmation page, no coding or theme changes required.
:::note
You'll need to define one or more [triggers](../triggers/index.mdx) for Real ID to start verifying customer IDs.
:::
## Configuring triggers
Triggers control which orders require ID verification. You can enable triggers like high-value orders, address mismatches, specific products, and more.
**[See all available triggers →](../triggers/index.mdx)**
Need to combine conditions — like verifying only high-value orders *that are also* flagged as risky? Switch the trigger settings to [Advanced rules](../triggers/advanced-rules/index.mdx) (Automate and Protect plans) to build AND/OR condition groups. The after checkout flow supports every condition, including payment method, delivery method, and order risk.
You can also [exclude certain orders](../triggers/exceptions.mdx) from verification — for example, already-verified customers, in-store pickup orders, or specific payment gateways.
## How it works
After a customer places their order, Real ID checks it against your triggers. If the order qualifies, the customer is prompted to verify their ID on the order status page, or through a link sent by email or SMS.
```mermaid
flowchart TD
order([Customer places order]) --> triggers{Order matches your triggers?}
triggers -- No match --> done([No ID check needed])
triggers -- Match --> recognized{Already verified? Recognized customer}
recognized -- Yes --> done
recognized -- No --> required([ID verification required])
required -- Customer submits ID photos --> verify{ID verification}
verify -- Passes your rules --> passed([ID verification completed])
verify -- Fails your rules --> failed([ID verification failed])
failed -. Staff member overrides results .-> passed
```
### What triggers an ID check
Real ID checks each order against your [triggers](../triggers/index.mdx) — for example high-value orders, address mismatches, or specific products. You can also [exclude certain orders](../triggers/exceptions.mdx), like already-verified customers or in-store pickups.
### Passing or failing your rules
After the customer submits their ID photos, Real ID checks them against your rules — age, face match, document expiry, and address or name cross-checks. Customers who pass are tagged `ID verification completed`. If a check fails, the order is shown as **In Review** so your team can [approve or reject it](../for-merchants/overridding-results.md).
### When emails are sent
- **When an order qualifies** — the customer gets an email or SMS with a link to verify their ID.
- **When the check passes** — the customer gets a confirmation, and your team gets a notification that the ID was verified.
- **When the check fails** — the customer is told their verification needs review, and your team gets a warning email with the reason.
You can turn any of these customer emails on or off in the **Notifications** area of your **Settings**.
### When tags and metafields are added
Because the order already exists, Real ID syncs ID verification [tags](../shopify/tags.md), [notes](../shopify/notes.md), and [metafields](../shopify/metafields.md) on both the order and the customer throughout the ID check lifecycle. The customer tag is what lets Real ID remember repeat customers so they only verify once.
On WooCommerce, Real ID syncs the ID check status as [metadata on the customer and order](../woocommerce/metadata.md), and can optionally [override the order's status](../woocommerce/order-statuses.md).
## Where the ID check is displayed
If you have the **after checkout** flow enabled and the order triggers an ID check then Real ID will display the ID check in the order status page within your site automatically.
It will also send the ID check via email and/or SMS if the customer provided their phone number during checkout.
### Adding the Real ID checkout block
With [Shopify Checkout Extensibility](https://help.shopify.com/en/manual/checkout-settings/checkout-extensibility/checkout-upgrade) enabled, you can add the Real ID checkout block to your Thank You and Order Status pages to prompt for ID verification after the customer has placed their order.
To add ID verification to the order status page, open the _Online Store_ sales channel from the left hand menu, and select _Themes_:

Now let's open the Theme Editor by selecting the _Customize_ button:

Once the theme editor is loaded, click the top dropdown to select the **Checkout & Customer Accounts** page:

You should now see a sample checkout page loaded. At the top of the page click the dropdown and select _Order status_:

Then at the bottom left hand side of the page, you'll see an _Add app block_ prompt. Click this button to show a menu of available blocks to add to the page:

Then, select the _ID verification_ block:

Now drag it to the top of the _Order details_ layout section on the page:

And that's it! Your customers will see a prompt to verify their ID if their order meets [one of your trigger conditions](../triggers/index.mdx), or if you've set up a [Shopify Flow workflow](../shopify/flow.md) to create ID checks for them.
### Block settings
When the block is selected in the theme editor, you'll see a **Show ID verification status** setting:

After a customer places an order, Shopify takes a moment to create the order and run its own fraud and risk analysis before the order details are available. This short delay is by design on Shopify's side, not Real ID — we can't determine whether an ID check is needed until Shopify finishes. This setting controls what the customer sees during that brief window:
- **False** (default) — the block stays hidden until a verification is actually required, then shows the prompt to verify. This is Real ID's standard behavior.
- **True** — the customer sees a short waiting message while we check whether their order needs ID verification, and a confirmation when none is required. This keeps them on the page until the result is known.
The setting is configured per page, so you can enable it on the Thank You page, the Order Status page, or both.
:::tip
Turn this on if you check every order for compliance and don't want customers navigating away before Real ID has finished checking their order.
:::
:::warning Legacy classic checkout
If your store still uses Shopify's classic checkout, Real ID currently injects the ID verification prompt into the order status page automatically. This stops working on **August 26, 2026**, when Shopify upgrades all remaining stores to the new Thank you and Order status pages.
Switch before then by following our [app blocks migration guide](../shopify/migrating-to-app-blocks.mdx) — your triggers and verified customers carry over automatically.
:::
### Selectors
WooCommerce's order status page is more customizable than Shopify. But WooCommerce's order confirmation page usually includes the class `.woocommerce-order`.
Real ID will look for these classes in the order confirmation page:
- `.woocommerce-order`
- `page-checkout`
- `woocommerce-order-received`
- `real-id-post-checkout-mount`
If none of the default WooCommerce class are available in your theme, you can place the ID check in the order status page by adding this CSS class to it: `.real-id-post-checkout-mount`
```html
```
See our [BigCommerce After Checkout guide](../bigcommerce/after-checkout.md) for platform-specific setup instructions, including how to display the ID check on the order confirmation page and configure custom trigger scripts.
For custom integrations, use the [JavaScript SDK](../js.mdx) to embed the ID verification flow on your order confirmation page. Add the SDK script tag and mount the flow on a target element:
```html
```
You can also create checks server-side via the [REST API](../api/checks.mdx) and deliver them by email or SMS, without embedding anything in your page.
## Frequently Asked Questions
### What happens if a repeat customer makes another order? Will they be prompted to verify their ID again?
In Shopify, Real ID leaves a special tag on all customers that have completed ID verification. If this tag `ID check completed` is present on the customer's profile, they will not be prompted to verify their ID again.
In WooCommerce, [Real ID updates meta on the customer account](../woocommerce/metadata.md) that they have completed ID verification.
:::info
Please note, it's uncommon but unverified customers can place multiple orders.
This will trigger multiple unique ID checks, one for each order placed. However, when the customer verifies their ID with at least one of these orders, then the customer will be verified for future ID checks. But the other in progress ID checks are independent and will need to be comleted or [manually approved](../for-merchants/overridding-results.md) by your staff.
:::
### What does this order status page look like when a customer fails ID verification?
If a customer fails their ID check, whether automatically or manually by you or your team - they will be notified by email and if they return to the order status page they'll be presented with a warning screen.
Then your staff will be able to review the photos and accept or reject them.
### Can customers automatically retry after they've failed their ID check?
By default, no customers will not be able to redo the ID check. This is by design, so that way you don't have uncontrolled costs on your ID check usage.
If you wish, you can send new ID checks to customers that fail on their first attempt manually. Or you can [enable automatic retries](../for-merchants/retrying-id-checks.md) and limit how many retries a customer is given.
### Will my customers still be notified by email or SMS after checkout as well?
Yes. Real ID will still send a notifications to your customer containing their ID verification link. The same ID check is delivered over your order status page, or by email and SMS.
### I'm using Shopify Classic Checkout, can I still use Real ID?
Yes, for now — Real ID automatically injects the ID verification prompt into the classic order status page. But Shopify is upgrading all remaining stores to the new Thank you and Order status pages on **August 26, 2026**, and the automatic injection stops working then. Your customers will still get their verification links by email and SMS, but the on-page prompt disappears.
Follow our [app blocks migration guide](../shopify/migrating-to-app-blocks.mdx) to switch before the deadline — your triggers and verified customers carry over automatically.
### Can I require ID verification during checkout, before the order is placed?
Yes! If you'd like customers to verify their ID _before_ they can submit their order, see our [during checkout guide](./during-checkout.md). This requires Shopify Plus with Checkout Extensibility enabled.
### I don't see a trigger that I need
See the full list of [available triggers](../triggers/index.mdx). If none of the built-in triggers fit your use case, on Shopify you can use our [Shopify Flow integration](../shopify/flow.md) to create ID checks based on any condition. On any platform, our [REST API](../api/checks.mdx) and [JS SDK](../js.mdx) can be used to create ID checks programmatically.
If you need help setting up a specific trigger for your business, [please contact us](https://getverdict.com/contact).
### If I switch from before checkout to after checkout ID verification, will my past verified customers still be remembered?
Yes, Real ID will track your customers ID checks even if you decide to switch between before or after checkout flows. There are some minor differences on how ID checks are tracked between the flows, but your verified customers will still be remembered even if you switch between the before or after checkout flows.
---
// File: flows/after-registration
# ID verification after account registration
Real ID can verify customer accounts after they have registered an account with your store.
Customers will be sent an email to their email address with their account after they have registered with your store, or had an account automatically created after check out.
## Getting started
To enable ID verification notifications to customers after they register an account, open the **Settings** page and select the **Automations** tab.

Then enable automatic ID veirfication and select the **After account registration** flow.

If you require ID verification before the customer can place an order, please see our [**Before Checkout**](./before-checkout.mdx) flow option instead.
:::tip
This flow does not block a customer from performing any actions like placing an order, creating a listing, etc. after they have registered.
- To prevent customers from starting an order please see the [Before Checkout flow](./before-checkout.mdx).
- To prevent unverified customers from viewing your store front entirely, please see the [Before Viewing Store flow](./before-viewing-store.md)
:::
### Sending ID checks based on customer role
If you're using Real ID in WooCommerce, you can define which roles should be sent an ID check notification. Otherwise, all new accounts are sent an ID check by default.
If you have a role that is custom, you can enter in the **slug** for the role. Then Real ID will also track this role for you:

---
// File: flows/before-checkout
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# ID verification before checkout
Due to specific age restrictions or K.Y.C. compliance requirements, you may require ID verification _before_ the customer can place the order.
The _before checkout_ flow will require ID verification before the customer can enter in their payment details and check out their order - _without_ any code changes to your theme.
Below is an example of a unverified customer being shown the prompt to verify their ID:

Then after verifying their ID, the **Checkout** button reappears automatically so they can continue checkout.
Real ID will override the **Checkout** button on your cart or product pages and replace it with a prompt to complete ID verification until the customer has passed ID verification automatically or a staff member has [manually approved it](../for-merchants/overridding-results.md).

:::tip Shopify Checkout Extensibility
The _before checkout_ flow is supported on Shopify, WooCommerce, and BigCommerce.
However, if you're looking for our Shopify Checkout app block to drag and drop directly on your checkout page, [see our During Checkout guide](./during-checkout.md). For programmatic control over in-checkout verification on any platform, see the [JS SDK](../js.mdx).
**Using BigCommerce?** See our [BigCommerce Before Checkout guide](../bigcommerce/before-checkout.md) for platform-specific setup instructions.
:::
## Getting started
To enable ID verification before checkout, open the **Settings** area and make sure you're on the **Automations** tab. Then click **Enable automated checks**.
This will open the different ID check flow options. Select the **Before checkout** option.
Finally, click **Save** to apply the check.

Then Real ID will automatically replace your site's checkout buttons with a prompt to verify your ID before purchase for unverified customers.
### Theme compatibility
By default Real ID works with most themes on Shopify and WooCommerce. It searches for common checkout or payment buttons on your entire site and will replace them in real time with the **Verify your ID** button instead.
However, if the customer is already verified, the checkout buttons will not be affected.
Here's a short list of selectors that Real ID uses to detect checkout buttons on the page:
For Shopify themes:
- `input[name='checkout']`
- `button[name='checkout']`
- `.real-id-checkout-button`
- `.verify-id-prompt`
- `#checkout`
- `a[href='/checkout']`
- `a[href='/checkout/']`
For WooCommerce themes:
- `.wc-proceed-to-checkout`
- `form[name='checkout']`
- `button.checkout`
- `a.checkout`
:::tip ID verification button not appearing?
You might have a very custom theme or have a side cart that doesn't render on the page load, when Real ID is searching for buttons that qualify for ID checks.
We can help with that! [Contact us for assistance.](/contact)
:::
## How it works
When a new customer starts checkout from the cart, they're prompted to verify their ID first. After they pass, the checkout button returns and they can place their order as normal.
```mermaid
flowchart TD
browses([Browsing storefront]) -- Customer clicks checkout --> triggers{Cart qualifies for verification?}
triggers -- No --> checkout([Checkout])
triggers -- Yes --> recognized{Already verified? Recognized by login or email}
recognized -- Yes --> checkout
recognized -- No --> required([ID verification required])
required -- Customer submits ID photos --> verify{ID verification}
verify -- Passes your rules --> checkout
verify -- Fails your rules --> failed([ID verification failed])
checkout --> order([Order placed])
failed -. Staff member overrides results .-> checkout
```
### What triggers an ID check
By default, the before checkout flow requires verification for **all products**. You can limit it to only [specific products or collections](#limiting-id-verification-to-specific-products) so customers verify only when their cart contains a restricted item.
Logged-in customers — and customers Real ID recognizes by email — skip verification when they've already passed.
### Passing or failing your rules
After the customer submits their ID photos, Real ID checks them against your rules — age, face match, document expiry, and address or name cross-checks. Customers who pass get their checkout button back and can place the order. If a check fails, a staff member can [manually approve or reject it](../for-merchants/overridding-results.md).
### When emails are sent
- **When verification is required** — the customer can get an email or SMS with a link to verify, so they can finish later if they leave.
- **When the check passes** — the customer gets a confirmation, and your team gets a notification that the ID was verified.
- **When the check fails** — the customer is told their verification needs review, and your team gets a warning email with the reason.
You can turn any of these customer emails on or off in the **Notifications** area of your **Settings**.
### When tags and metafields are added
Because the customer verifies before placing their order, their customer account and order are created at checkout. Real ID then adds ID verification [tags](../shopify/tags.md), [notes](../shopify/notes.md), and [metafields](../shopify/metafields.md) to both the new customer account and the order. The customer tag is what lets Real ID remember repeat customers so they only verify once.
### How already verified customers are recognized
Returning customers won't be required to complete ID verification again, but for best results; guide customers to login before they start checking out.
If a returning customer isn't logged in but enters the same email address from a prior ID check, Real ID sends them a 6 digit confirmation code to verify they own that email before loading their verified check. You can turn this requirement off — so a matching email is trusted automatically without a code — using the **Require email confirmation code for returning customers** setting. See [trusting the email address without a code](./remember-repeat-customers.mdx#trusting-the-email-address-without-a-code) for the trade-offs.
For more details on how Real ID recognizes already verified customers, [please see our documentation here](./remember-repeat-customers.mdx#before-checkout-flow).
### Overriding ID check results
Some customers may have extraordinary circumstances that keeps them from successfully passing an ID check automatically.
You can override the ID check requirement for individual customer, to allow them to complete checkout.
When the customer first opens their ID check, they're presented with a form to enter in their name and email address.

Using the customer's name and email address, you'll be able to search for their in progress ID check in the search bar.
Then with the check open, manually approve it to allow the customer to continue.
:::tip
After manually approving a customer's ID check, they should see they have passed within 10 seconds. However, you can instruct the customer to refresh the page if it's taking longer than expected.
:::
## Limiting ID verification to specific products
By default, Real ID will require ID verification for _all products_ if the **Before checkout** flow is enabled.
You can only require ID verification if the customer's cart only contains one or more restricted products.
Within the **Automations** area of the **Settings** page, scroll down the to **Filters** section to see the products and collections filters:

To enable ID verification on a specific collection for example, click **Collections** then enable the feature, and search for a collection. Clicking on the collection will require ID verification if the customer's cart contains one or more products from this collection.

:::tip
As a best practice, we recommend that you create a single collection with the name `ID verification required`, and add products to it, and track it with this feature.
Then you can add additional products without having to also update them individually in Real ID.
:::
Within the **Automations** area of the **Settings** page, scroll down the to **Filters** section to see the products filter:

To enable ID verification on a specific category of products for example, click the toggle under the **Categories** then enable the feature, and click on a collection. Clicking on the collection will require ID verification if the customer's cart contains one or more products from this categories selected.

Lastly, don't forget to click **Save** in the upper right hand corner of the page to save your changes.
See our [BigCommerce Before Checkout guide](../bigcommerce/before-checkout.md) for platform-specific setup instructions on limiting ID verification to specific product categories.
For custom integrations, you control which products require ID verification in your own application logic. Use the [JS SDK](../js.mdx) to conditionally mount the verification flow based on the customer's cart contents, or use the [REST API](../api/checks.mdx) to create checks server-side only for qualifying orders.
## Adding ID verification to any button
Real ID will automatically recognize normally structured checkout buttons on your product and cart pages. However you may have a custom theme or a custom button that will need to be gated by ID verification.
You can trigger ID verification to any button on your site by adding the `verify-id-prompt` class to the button. For example:
```
```
This will replace the **Buy it now** button, with a **Verify your ID** button instead. Once the customer passes ID verification, the **Buy it now** button will return and become clickable.
## Side Carts
A side cart is a JavaScript-powered shopping cart interface that slides out from the side of a webpage, typically triggered when customers add products to their cart or click a cart icon. Unlike traditional cart pages, side carts are created dynamically after the initial page load.
### Automatic Support
Real ID automatically supports most popular side cart implementations by monitoring common cart interaction elements. When customers interact with these elements, Real ID automatically reinitializes to scan for new checkout buttons that may have appeared.
However, some custom side cart implementations may not be automatically detected.
### Manual Integration for Unsupported Side Carts
If your side cart isn't automatically supported, you can manually trigger Real ID reinitialization by adding the `.real-id-initialize` class to any element that opens your side cart:
```html
```
### Need Help with Your Side Cart?
If you're having trouble getting Real ID to work with your custom side cart implementation, our team can help you identify the right integration approach for your specific setup.
[Contact our support team](https://getverdict.com/contact) and we'll work with you to ensure your side cart works seamlessly with Real ID verification.
## Hiding elements that require ID verification
You can also hide product images, descriptions or any other element that requires a verified ID by adding the class `hidden-until-verified` class:
```
This product is only available to customers with a verified ID.
```
## Styling the start verification button
The button that starts verification is customizable without code through the [appearance section in the settings](../theming/branding.md).
But if that doesn't meet your exact criteria, you can use CSS within your site's theme to modify additional properties such as the border, border radius, shadows and more.
The Real ID verification button has the class name `.real-id-start-verification`, which you can use to apply custom styling via CSS rules. Here is an example:
```
button.real-id-start-verification {
border-radius: 5px; /* Adjust the value to control the amount of rounding */
}
```
## Troubleshooting
### Occasionally unverified customers checkout
If your seeing orders come through occasionally where customers can still checkout without completeing their ID check, you can follow these steps.
In Shopify, the *before checkout* flow is restricted to only modifying the *Checkout* buttons on your site's frontend. This means it's not possible to guarantee verification before checkout for all cases, but to help reduce that risk:
1. **Recommended** consider using the [during checkout flow](./during-checkout.md) instead. This is a Checkout Extension that doesn't have the same compatibility or performance issues as the before checkout flow.
2. Make sure other apps are not modifying the checkout buttons on your order status page. Apps that add checkboxes, or rental date pickers will occasionally override the Real ID app's verification button.
3. Make sure your page isn't loading another app's JavaScript or theme JavaScript that is blocking Real ID from loading performantly.
4. Make sure that all checkout buttons across all side carts, product pages and your cart pages have the checkout button overridden for verification. You can [use CSS classes](#adding-id-verification-to-any-button) to add ID verification to any checkout button.
In WooCommerce classic shortcode checkout, Real ID will validate the customer has verified their ID before allowing them to continue:

However, please make sure that the Real ID button is placed on your website in the appropriate locations, otherwise customers won't be able to checkout and won't know where to verify their ID to continue to checkout. You can use the [Real ID CSS classes](#adding-id-verification-to-any-button) to add ID verification to any button on your site.
This means that customers won't be able to complete checkout if their ID isn't verified. However, if your checkout is using the new **Checkout Blocks** instead, there unfortunately isn't validation at this time. We're currently working with WooCommerce to add checkout validation hooks for developers to block checkout on custom conditions, like ID verification status.
See our [BigCommerce Before Checkout guide](../bigcommerce/before-checkout.md) for platform-specific troubleshooting steps.
For custom integrations using the [JS SDK](../js.mdx), ensure that:
1. The SDK script tag is loaded before your checkout button renders.
2. The `target` selector in `RealID.createFlow()` matches your actual checkout button.
3. No other scripts are removing or replacing the verification gate before the customer verifies.
If you're using `mode: "modal"`, the checkout button is hidden until the customer passes verification. Listen for the [`real-id-check-passed` event](../js.mdx#events) to confirm the gate was lifted.
### Shopify
#### **Buy it now**, Shop Pay, Apple Pay, and Google Pay buttons bypass ID verification
Shopify renders dynamic checkout buttons — **Buy it now**, **Shop Pay**, **Apple Pay**, and **Google Pay** — inside an iframe that themes and apps cannot modify. Because Real ID's _before checkout_ flow works by replacing checkout buttons on the page, it can't override these dynamic checkout buttons. A customer who clicks one of them will skip ID verification and go straight to checkout.
If you sell products that require ID verification, we recommend one of the following:
1. **Recommended** — use the [during checkout flow](./during-checkout.md) instead. It runs as a Checkout Extension inside Shopify checkout itself, so it gates _every_ checkout path, including **Buy it now**, **Shop Pay**, **Apple Pay**, and **Google Pay**.
2. If you'd like to keep using _before checkout_, disable the dynamic checkout buttons on products that require ID verification. Most Shopify themes offer a setting (in the theme editor or on the product page itself) to hide these buttons — with them off, customers are forced through the cart, where Real ID can replace the **Checkout** button with the verification prompt.
### WooCommerce
#### The **Verify your ID** button stopped appearing on my site, or it's failing to load after clicking the button suddenly
If you're using a caching plugin such as **Speed Optimizer** to bundle JavaScript scripts, you'll need to exclude the Real ID script from the bundle.
If you have **Speed Optimizer** installed, you can tell if you have this feature enabled by opening the plugin, then clicking **Frontend** and open the **JavaScript** tab. Check to see if the the **Combine JavaScript Files** feature is enabled:

If this feature is enabled, you'll need to exclude the Real ID script by opening the **Exclude Scripts** popup and selecting the `https://real-id-flow.getverdict.com/assets/index.js` script:

Then click **Confirm** to confirm the exclusion of the Real ID script from the Speed Optimizer's bundle of scripts:

After you've confirmed this change, refresh the page and you should see Real ID working properly once again.
---
// File: flows/before-viewing-store
# ID verification before viewing store
Require ID verification before customers can even view your store. Real ID has a flow just for you, no code required.
Real ID has a built in flow to require customers to sign in or register an account with your store, and verify their ID before they can view your store, open their cart or checkout.
Unregistered guest customers will be greeted with a page to explain that ID verification is required to proceed:

Then after they login, they'll be prompted to verify their ID.
## How it works
This flow will require the customer to login or register an account _and_ also verify their ID before they can continue to see the products on your store, or checkout an order.
Real ID will modify your storefront to add this functionality - no code required.
Here's what the customer journey from guest to verified customer looks like:
```mermaid
flowchart TD
browses([Browsing storefront]) -- Unregistered guest prompted to login or register --> register
register([Signs up]) -- Customer registers an account, ID check associated with their account --> id_check_prompt{ID verification prompt}
id_check_prompt([ID verification prompt]) -- Customer submits ID photos --> id_check_processed{ID verification}
id_check_processed -- Customer fails ID check --> id_check_failed([ID verification failed])
id_check_processed -- Customer passed ID check --> checkout([Checkout])
checkout -- Order placed --> confirmation([Order confirmation])
id_check_failed -. Staff member overrides results .-> checkout
```
## Setting it up
To enable this flow, first open the **Automations** section of the **Settings** within Real ID:

Then you can enable this flow by enabling **Automatic Verification** and then selecting **Before viewing store**:

### Adding pages unverified customers are allowed to view
By default, Real ID will only allow your store's account registration and login pages to be viewed by unverified customers.
This is the required so they can sign up and verify their new account.
But you can add individual pages that unverified customers and guests alike can view without ID verification, such as your privacy policy page, or a page explaining this ID verification policy.
To add a new page that doesn't require ID verification, scroll down in the **Automations** section of the **Settings** page and add additional pages by their link.

Don't forget to click **Save** when you're finished!
### Changing the appearance and content
To change the theme and the content explaining the ID verification process and why it's required for your store, you can visit the **Appearance** section of the **Settings**.

Then click on the **Registration** tab to change the ID verification gate content:

This content is shown to unregistered guests, so it should clearly communicate that the ID verification process is:
- Required for viewing your store
- Takes just few minutes to complete
- Only needs to be done once for their account
- It's secure and encrypted
In addition to changing this content, you can also add additional buttons that link to pages on your store. These are helpful for making links to privacy policy pages, or pages that explain further why ID verification is required.
:::note
Make sure the links are allowed to be visited by guests, otherwise guests won't be able to open them.
:::
### Optimizing your Shopify Theme
You can optimize your theme to prevent unverified customers from viewing any details while the ID check loads.
By using a bit of liquid code checking the [customer's metafields](../shopify/metafields.md), you can make sure unverified customers cannot navigate or view your store at all without verification.
:::tip Code changes required
This modification requires code changes to your theme. Please make a backup of your theme before making changes.
:::
First, open your Online Store Theme Editor, and then open the **Edit Code** dropdown:

Once the code editor is open, open the `layout` folder and open the `theme.liquid` file. This file wraps all of your sections and contains the header, footer and body of all of the pages on your store.

Now search for the keyword `content_for_layout` in this theme code. You can use `CMD + F` or `Ctrl + F` to search for this in the page. It will be between the header and footer sections of your site.
It should look something like this:
```ruby
{% sections 'header-group' %}
// highlight-next-line
{{ content_for_layout }}
{% sections 'footer-group' %}
```
Once you find this `{{ content_for_layout }}` line, you can wrap it with a conditional to check the customer's verification status:
```liquid
{% sections 'header-group' %}
// highlight-start
{% if request.design_mode or request.visual_preview_mode or request.path == routes.account_url or request.path == routes.account_register_url or request.path == routes.account_login_url or request.path == routes.account_recover_url or customer.metafields.real_id.verified %}
{{ content_for_layout }}
{% else %}
Loading...
{% endif %}
// highlight-end
{% sections 'footer-group' %}
```
Then click **Save** in the top right of the code editor to apply these changes. Last step, don't forget to **Publish** this copy of the theme if you started from a duplicate.
This code is checking to see if:
- The customer is logged in and verified
- If the customer is on public pages like the login, registration and password reset pages
- If this page is being viewed within the Shopify theme editor
If none of those conditions are present, then the ID check prompt is shown to the customer.
:::info JS SDK for advanced use cases
If you need even more control over when the ID check is shown and how it's displayed, [use our JavaScript SDK](../js.mdx) to craft a more custom experience.
:::
## Styling the start verification button
The button that starts verification is customizable without code through the [Appearance section in the settings](../theming/branding.md).
But if that doesn't meet your exact criteria, you can use CSS within your site's theme to modify additional properties such as the border, border radius, shadows and more.
The Real ID verification button has the class name `.real-id-start-verification`, which you can use to apply custom styling via CSS rules. Here is an example:
```
button.real-id-start-verification {
border-radius: 5px; /* Adjust the value to control the amount of rounding */
}
```
## Setting up on WooCommerce
Setting up an ID gate in WooCommerce requires a few more set up steps for the gate to function properly.
### Allow users to register
Customers will need to be able to register accounts on your site in order to complete the ID verification process.
Follow these directions to allow customers to register their own accounts on your WooCommerce site:
1. Login to your WordPress admin
2. Open **Settings**
3. Open **General**
4. Near the middle of the page, under the **Membership** option, check the **Anyone can register** option.
5. Scroll to the bottom of the page and click **Save Changes** to apply the change

### Allowing the customers to view the login page
By default, Real ID will allow unverified guests to vist the `/my-account` page on your site.
However, if you have a different page for registering, logging in and resetting a password, you'll have to add [these pages as allowed pages](#adding-pages-unverified-customers-are-allowed-to-view).
:::tip
For the best experience, we recommend using the **Post name** permalink structure for your WordPress site. The default allowed pages assume this peramlink structure.
:::
## Frequently Asked Questions
### Do I need to make any modifications to my theme for this to work?
No, Real ID is compatible with most Shopify themes. There may be themes that might not be compatible out of the box, or apps that add frontend elements that need to be covered by the ID check gate.
If your theme isn't working as expected, [please contact us for help](mailto:support@getverdict.com).
### Will customers only need to verify once?
Yes, customers will only need to verify their account once. Even if they switch devices or log off, they can log back into their account and it will stay verified.
### What if a customer has an issue with completing their ID check?
If a customer is having difficulty completing their ID check, or they have failed it, you still have the ability to override their ID check.
Manually approving a customer's ID check will automatically verify their account and allow them to continue to browse your storefront.
:::note
After manually approving a customer, we suggest that they refresh their browser for the latest update.
:::
---
// File: flows/during-checkout
# ID verification during checkout
Using Real ID's app blocks for your Shopify checkout page, you can require ID verification at any point during the checkout process. Customers will be required to verify their ID before they can submit their order.
This short video shows you how to set this up on your Shopify store step by step:
:::tip Shopify Checkout Extensibility Required
Your Shopify checkout must upgrade to [Shopify Checkout Extensibility](https://help.shopify.com/en/manual/checkout-settings/checkout-extensibility/checkout-upgrade) to use this ID verification flow.
At this time only _Shopify Plus_ stores have access to checkout customizations through app blocks. If you do not have a Plus subscription, but require customer ID verification _before purchase_ consider our [before checkout flow](./before-checkout.mdx) instead.
:::
## Setting up Real ID
To get started, first open the Real ID app. Then open the **Settings** page.
Enable automatic verification in the **Triggers** tab, then select the **Shopify Checkout Extensibility** tab to view the available options.

Then select **During checkout** option. Don't forget to click **Save** in the top right of the Real ID app to apply the flow.

## Adding the ID verification app block to your theme
Now open the **Online Store** channel in Shopify, click the **Theme** section and click **Customize** to open the theme editor.

With the theme editor open, click the page dropdown and select the **Checkout** page.
Then at the bottom of the page, you'll see a button to **Add app block**, click this to view all available app blocks.

Click the **ID verification** app block to add it to your checkout page.

:::tip
Make sure the **Enable app to block checkout** option is checked. Otherwise the app block will not be able to block unverified customers from checking out.
:::
Now that the app block is added to your checkout, Real ID will automatically require unverified customers to complete ID verification before continuing through the checkout flow.
Logged in verified customers will not be required to complete ID verification.
If you'd like to change the position of the ID verification prompt in the checkout page, simply hover over the app block and drag it up or down between the other checkout blocks.

## How it works
When a customer reaches checkout, Real ID looks at their cart and checkout details to decide whether ID verification is required. If it is, they're prompted to verify before they can place the order.
```mermaid
flowchart TD
checkout([Customer reaches checkout]) --> triggers{Cart or checkout details match your triggers?}
triggers -- No match --> proceed([Checkout continues normally])
triggers -- Match --> recognized{Already verified? Recognized by login or email}
recognized -- Yes --> proceed
recognized -- No --> required([ID verification required])
required -- Customer submits ID photos --> verify{ID verification}
verify -- Passes your rules --> passed([ID verification completed])
verify -- Fails your rules --> failed([ID verification failed])
passed --> order([Order placed])
failed -. Staff member overrides results .-> order
```
### What triggers an ID check
Real ID checks each checkout against your [triggers](../triggers/index.mdx) — for example:
- [Specific products or collections](../triggers/specific-products.mdx) in the cart
- A [high-value order](../triggers/high-value-orders.md) above your price floor
- Shipping to [specific U.S. states](../triggers/us-shipping-states.mdx) or regions
You can also combine conditions with AND/OR logic using [Advanced rules](../triggers/advanced-rules/index.mdx) (Automate and Protect plans) — for example, requiring verification only when a restricted product ships to a specific state.
If nothing matches, the customer checks out as normal. If something matches, they verify before placing the order. Logged-in customers — and customers Real ID recognizes by email — skip verification when they've already passed.
### Passing or failing your rules
After the customer submits their ID photos, Real ID checks them against your rules — age, face match, document expiry, and address or name cross-checks. Customers who pass can place their order right away. If a check fails, the order is held for [manual review](../for-merchants/overridding-results.md), where a staff member can approve or reject it.
### When emails are sent
- **When verification is required** — the customer can get an email with a link to verify, in case they leave checkout before finishing.
- **When the check passes** — the customer gets a confirmation, and your team gets a notification that the ID was verified.
- **When the check fails** — the customer is told their verification needs review, and your team gets a warning email with the reason.
You can turn any of these customer emails on or off in the **Notifications** area of your **Settings**.
### When tags and metafields are added
- **Metafields** are written to the order as the customer verifies during checkout, so `real_id.verified` and `real_id.check_id` are already on the order the moment it's placed.
- **Tags and notes** are added to both the order and the customer shortly after the order is placed. The customer tag is what lets Real ID remember repeat customers so they only verify once.
See [Tags](../shopify/tags.md), [Notes](../shopify/notes.md) and [Metafields](../shopify/metafields.md) for the full list.
## Remembering already verified customers
By default this flow option will already remember verified customers. First the system will attempt to find their past verified ID by the customer's Shopify account, then it will attempt to find the customer's ID check based on the customers email address.
### By Shopify account
The customer will need to be **logged in** in order for Real ID to detect their current verification status by their Shopify account.
Please make sure that your Shopify store allows customers to login to their accounts.
You can check this by opening the **Settings** section of your Shopify store, then opening the **Customer Accounts** area.

At the top of this section, you'll see the option to allow customers to login to their own accounts, make sure it's enabled. The option is labeled as **Show login link in the header of online store and at checkout**.
Then choose between **Classic customer accounts** or **New customer accounts**. Real ID is compatible with either choice.
The main difference between the two is that the **New customer accounts** choice will require the customer to open a link sent to their email address in order to login.
Whereas the **Classic customer accounts** allows email address and password combinations to login, which allows account sharing if you have the email address and password.
### By email address
If the customer isn't logged in, then the system will attempt to find their past verified ID by the customers email address.
If any check is found by the customer's email address, then it will prompt the customer to confirm ownership of the email address through a confirmation code.
After the customer enters in their confirmation code, they will be recognized and allowed to complete checkout even without logging in.
## Other platforms
The during checkout flow above uses Shopify's Checkout Extensibility and is only available for Shopify Plus stores.
If you need in-checkout ID verification on other platforms, you have two options:
- **JS SDK**: Use the [Real ID JavaScript SDK](../js.mdx) with `mode: "modal"` to gate any checkout button on any platform — including WooCommerce, BigCommerce, or custom sites. The SDK replaces the target element with an ID verification prompt and restores it after the customer is verified.
- **Before checkout flow**: The [before checkout flow](./before-checkout.mdx) works across Shopify, WooCommerce, and BigCommerce without any code changes. It replaces checkout buttons site-wide until the customer has verified their ID.
## Frequently Asked Questions
### Will ID verification be required for draft orders as well?
Yes, the same ID verification app block will appear for draft orders, even in the checkout links shared from the POS or from the Shopify Admin.
### How can I restrict ID checks to specific shipping locations with specific products in the cart?
If you require ID verification for specific countries or regions only for specific products like knives, [please contact us](https://getverdict.com/help/contact) for support. We have custom triggers for this use case.
### Can I still allow customers to check out, even if they've failed to verify their ID automatically?
Yes, in the **ID verification** app block in your checkout page in your Shopify theme, untick the **Allow app to block checkout** checkbox and then save your change.

This will allow unverified customers to continue through to checkout.
:::warning This includes customers that don't submit their ID at all
If you choose to disable the ID verification requirement, it will also allow customers to checkout even if they do not upload any photos whatsoever.
:::
---
// File: flows/remember-repeat-customers
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# Remember verified customers
Real ID can track which of your customers have already completed ID verification once. This way your customers can return and make repeat purchases without requiring ID verification on each purchase.
If enabled, Real ID will remember repeat customers and not require already verified customers to provide photos again.
## Enabling Remembering Repeat Customers
In the settings of the app, open the **Automations** tab. If you're using ID verification after checkout open the **Exceptions** tab.
Then click the checkbox next to **Customers only need to verify once** to enable the feature.

## How are verified customers tracked?
Real ID will associate the completed ID check with your customer's account on your store. There are some differences between the out of the box ID verification flows, we'll go into those details below.
### After checkout flow
When a already verified customer returns to your store to checkout again, Real ID will automatically find the completed or manually verified ID check in the database of your store's ID checks and count the customer as verified.
On Shopify, customer profiles with the `ID verification completed` or `ID check manually approved` tags are considered verified.
Real ID [automatically updates tags on orders and customers](../shopify/tags.md) during the ID check lifecycle. If a returning verified customer places an order using the same email address _or_ the is logged into their account on your store before placing the order, then Shopify will associate that order with their prior account that includes the `ID verification completed` or `ID check manually approved` tags.
Real ID will receive this order notification and see that the customer is already verified, so the returning customer won't be prompted for verification on their new order.
On WooCommerce, customer profiles with the `real_id_check_status` set to `completed` or `manually_approved` will be considered verified. Real ID automatically [updates metadata](../woocommerce/metadata.md) on both orders and customers during the ID verification lifecycle.
If an already verified customer returns using the same email address as their prior order _or_ they are logged into their account before purchasing, then Real ID will not prompt the customer to verify again.
On BigCommerce, Real ID tracks verified customers using [metafields](../bigcommerce/metadata.md) under the `realid` namespace. When a customer completes ID verification, their customer profile's `realid.verification_status` metafield is set to `verified` (or `manually_approved` if a staff member manually approved the check).
When an already verified customer places a new order, Real ID will look up the customer by their BigCommerce customer ID and find the completed ID check in the database. If a prior verified check is found, the customer won't be prompted for verification on their new order.
For custom integrations, Real ID tracks verified customers by their email address. When a returning customer starts the [JS SDK](../js.mdx) flow or a new check is created via the [REST API](../api/checks.mdx), Real ID will look up prior completed checks by the customer's email.
If the customer has a prior completed or manually approved check, the JS SDK will automatically recognize them as verified — no additional integration is required on your end.
### Before checkout flow
If you're requiring ID verification before or during checkout, before the order is placed, then Real ID uses three different methods to determine if a returning customer is already verified:
1. [From browser cookies](#from-browser-cookies)
2. [From the customers login (recommended)](#from-the-customers-login)
3. [From the customers email address](#from-the-customers-email-address)
:::info
In the **before checkout** flow, Real ID does **not** use tags or metafields to consider the customer verified.
:::
#### From browser cookies
Because customers can be unregistered at the time they verify their ID, Real ID will place a cookie within their browser to mark them as verified. Then after the customer completes checkout, their account will be associated with the ID check in Real ID's database.
That way, if the customer switches browsers or devices in the future, they can still login to their acccount on your store and remain verified.
However, this is the most brittle of the methods. Customers may switch devices, or browsers, or have their browsers to block cookies.
If an unregistered customer blocks cookies, they'll still be able to verify their ID as well as look it up using their email address when returning to your store.
#### From the customers login
Customers can also log into their account on your store and Real ID will automatically recognize them as verified.
After the customer logs in, Real ID will not require them to verify their ID again. Instead they'll be able to checkout directly.
For this feature to work properly, we highly recommend enabling customer accounts and allowing customers to login to their accounts.
#### From the customers email address
If a returning customer isn't logged in, but they enter in the same email address from their account, then Real ID will recognize their past ID check.

The customer will be sent a 6 digit confirmation code to their email inbox. When the customer enters
in this 6 digit code into the Real ID prompt, it will automatically load their corresponding ID check.

If they have a prior verified or manually approved ID check, then the customer will be able to complete the order.
This way, even if the customer isn't logged in, Real ID will recognize their already completed ID check.
:::info
This feature includes ID checks that are in progress, in review, or manually rejected by your staff.
If you'd like to allow the customer to try again, use the resend ID check feature to send the customer a brand new ID check for them to attempt again.
:::
:::tip
You are not charged for customers that return using their prior ID check from a confirmation code.
:::
#### Trusting the email address without a code
By default, returning customers must enter a 6 digit confirmation code to prove they own the email address before their prior ID check is loaded.
If you'd prefer a faster experience, you can turn this requirement off so that a returning customer who enters a matching email is recognized automatically — no confirmation code is sent or required.
To change this, open the **Settings** area and make sure repeat customer remembering is enabled. Then in the **Email verification for returning customers** section, turn off **Require email confirmation code for returning customers**.
This setting works the same way on Shopify, WooCommerce, and BigCommerce.
:::caution Consider the security trade-off
When the confirmation code is disabled, anyone who enters a previously verified email address is treated as that verified customer — without proving they actually own the inbox. We recommend keeping the confirmation code enabled unless you have a specific reason to trust email entry, such as a checkout where the email is already verified by your platform.
:::
## How can I tell in my store admin if a customer is considered verified?
You can view your customers verification status witin your eCommerce platform's dashboard.
[Real ID automatically tags orders and customer profiles](../shopify/tags.md) in your Shopify dashboard. When a customer completes ID verification, their profile is tagged with `ID verification completed`. Additionally, if you elect to manually approve an ID check, the customer will be tagged with `ID check manually approved`. Either one of these tags counts the customer as permanently verified for future orders.

:::note Tags can be edited outside of Real ID's control
Since tags can be modified in the Shopify Admin, they do not dictate if an order is verified or not. The customer must have a prior completed or manually approved ID check to be considered verified.
:::
Additionally, Real ID also updates the metafields on the customer's account as they complete ID verification.
You can view the metafields of a customer within your Shopify dashboard, by visiting the customer's profile.
Metafields are also accessible in your store's theme within liquid templates, which allows you to craft feedback to the customer in their account page if they are verified.
Real ID uses meta data on the customer's user profile to store their ID verification status.
You can view this meta within your theme, or within the WordPress dashboard.
Real ID uses [metafields](../bigcommerce/metadata.md) on both customer and order profiles to store ID verification status. The `realid.verification_status` metafield reflects the current state of the customer's ID check (e.g., `verified`, `manually_approved`, `failed`).
You can view a customer's verification status directly from the BigCommerce admin using the Real ID [customer panel](../bigcommerce/viewing-ids.md#from-customer-details), which shows the current verification status and a full history of all ID checks for that customer.
You can also access these metafields programmatically through the [BigCommerce Metafields API](https://developer.bigcommerce.com/docs/rest-management/customers/customer-metafields).
You can view the verification status for any customer's ID check in the Real ID dashboard, or retrieve it programmatically via the [REST API](../api/checks.mdx#retrieve-an-id-check).
The check's `step` field indicates the current status — `completed` for verified customers, `in_review` for pending manual review, and so on. Use [webhooks](../api/webhooks.mdx) to get notified in real time when a customer's status changes.
## Expired IDs
IDs such as driver's licenses commonly feature an expiration date. After the expiration date passes, the ID is no longer valid. For example, a U.S. issued drivers license can be unexpired at the time of verification, but in the future that ID's expiration date will pass and the ID is no longer valid.
Real ID will automatically invalidate expired IDs for you, so that way you can tell the ID is now expired:
- On **Shopify**, the customer's profile tag is updated to `ID expired`.
- On **WooCommerce**, the customer and order [`real_id_check_status` metadata](../woocommerce/metadata.md) is set to `expired`. The order's WooCommerce status is left unchanged.
The next time the customer returns to place an order, they will be prompted to verify their ID again.
### Example
A customer Jane Doe verified her ID for her purchase on your store. Her ID isn't set to expire until January 1st 2030. Jane Doe will be automatically verified for future purchases.
After January 1st 2030 Jane's ID will be expired and no longer valid. Real ID will automatically update her profile to `ID expired` which will invalidate her ID. The next time Jane makes a purchase from your store, she will be prompted to verify her ID once more.
:::note IDs without expiration
Some forms of ID do not feature an expiration date, or Real ID may not be able to confidently read the expiration date on the ID and the ID is [manually approved](../for-merchants/overridding-results.md) by your staff.
In these cases, Real ID will not be able expire these IDs automatically because there is not expiration date to invalidate.
:::
## Frequently Asked Questions
## Does this feature work with manually approved customers?
Yes! If you manually approve a check, Real ID will also count this as a successful verification.
Manually approving an ID check will tag the customer with "ID check manually approved", and future orders will count as verified.
:::tip Manual approval can happen without ID photos submitted from the customer
You can manually approve an ID check at any time, even if the customer has not actually submitted any photos.
Please be certain you intend to manually override a customer's ID verification for their order or account, because on future purchases they will not be prompted again if manually overridden.
:::
## Does this work with the before checkout and before viewing store flows?
Yes, by default Real ID will remember your already verified customers if you decide to require ID verification before checkout or before customers can view your store.
## How can I pre-approve customers in the **before checkout** flow?
You can pre-approve customers in the before checkout flow by starting an ID check manually for them, and then manually approving the ID check immediately after sending it.
That way, an ID check is created in Real ID's database for that account, and [they can use their email address at checkout](#from-the-customers-email-address) to link the ID check to their account.
They will not be prompted to submit photos, and their already manually approved check will be used.
## Do I need to require customers to have an account to be remembered for future purchases?
No, this is not required.
Real ID associates a verified ID with the customer's account as well as their email address used for their order. That way even if the customer doesn't have an account with your store, we can use their email address to look up their verified ID automatically.
---
// File: for-merchants/archiving-id-checks
# Archiving ID checks
If you are manually reviewing failed or verified ID check photos as part of your order fulfillment workflow, you may want to remove already manually reviewed checks from your ID check timeline in the app.
This is where archiving ID checks comes in handy. You can archive ID checks you have already reviewed, and they'll be removed from the home page of the app.
This allows you to clean up your already viewed ID checks, while still keeping their results.
## Only show archived ID checks
In the home page, select the **Archived** filter to only show ID checks that have been archived. From this view, you can also unarchive one or more ID checks using the bulk selection tool.

:::info
Archiving ID checks does not delete photos, data or modify tags in any way.
Archiving only affects how the ID check is shown in your dashboard when you first open Real ID.
:::
## How to archive an ID check
You can archive ID checks from either the ID check details page, or from the home page itself.
When viewing a specific ID check, you can archive it in the top menu of the page:

### Archiving multiple ID checks
You can archive multiple ID checks at once on the home page. Click the checkbox next to each ID check you'd like to archive, then click the **Archive Check** button in the toolbar to archive them all at once:

## How to unarchive an ID check
From an individual ID check, you can unarchive using the top menu of the ID check:

### Unarchiving multiple ID checks
You can also unarchive multiple ID checks with a single click. First apply the **Archived** filter in the top right of the toolbar, then click on each checkbox next to the ID check you'd like to unarchive.
Finally, click **Unarchive Checks** to unarchive all selected ID checks.

:::info
Don't forget to apply the **Archived** ID check filter before attempting to unarchive the checks, otherwise the **Unarchive** button will not appear.
:::
---
// File: for-merchants/automatic-id-check-reminders
# Schedule automatic ID check reminders for customers
You can increase your ID check completion rate by scheduling reminders in the Real ID app. Customers are busy too, they may not be able to complete ID verification after their order, and you can automatically follow up with them using Real ID.
Watch this short 2 minute video to learn how to enable this feature and customize it, or follow the instructions below:
:::info Only available for after checkout
This feature is only available for ID checks sent manually or [sent automatically by an **after checkout** trigger](../flows/after-checkout).
Automatic reminders will **not** be sent for [ID checks prompted before checkout](../flows/before-checkout).
:::
## How to enable automatic ID check reminders
Within the app, open up the Notifications area in the settings page.
Then you'll should see the Customer ID check Notifications section:

Enabling this feature will show three default emails that are scheduled for reminding the customer to complete their ID verification:

## How to change the schedule and content of the emails
To change the body, subject and the delay of a given reminder, click on it.
In the popup, you'll be able to adjust the subject line, body and choose how long to wait to send the email:

[You can use shortcodes to personalize the message with the customer's name and their order number.](../theming/customize-content#shortcodes)
## Frequently asked questions
### Is this an additional charge for using automatic reminders?
No, this feature is not an additional charge to your ID check. But there is a limit to the number of emails you can reschedule.
### If the customer completes their ID check, will they still receive emails?
No, when the customer completes their ID check, the rest of the scheduled reminders are immediately cancelled. The customer will not be reminded again, because they have submitted their ID.
### How many reminders can I schedule?
Real ID comes with 4 reminders maximum per schedule. If you need additional reminder slots, [please contact us](/contact).
### Will automatic reminders be sent for ID checks triggered by before checkout or before viewing store flows?
No, automatic ID verification reminders are only available for the [after checkout flow](../flows/after-checkout), or ID checks sent manually.
---
// File: for-merchants/deleting-data
# Deleting ID check data
You can delete customer data manually through the app at any time.
To delete a customer's photos and data, open the ID check and select **Delete Customer Photos** in the top action menu.

You'll be prompted to confirm the deletion.
:::warning This is permanent
Deleting customer data is an irreversible actions. This will permanently scrub and remove all customer photos and data from Real ID's vaults and databases.
:::
## Data deletion logs
After a customer's data has been deleted, the ID verification timeline updates to show exactly when the customer's ID data was deleted:

## Frequently asked questions
### Will deleting a customer's data also wipe their verification status? Will they need to verify again?
No, deleting the stored ID information will not unverify the customers account. That way they can make future orders without being prompted to verify again.
Real ID [updates the customer's profile on your eCommerce platform](../flows/remember-repeat-customers.mdx), so that way they are flagged for future orders.
### Will customers receive a notification when their data is permanently deleted?
Yes, customers will be notified by email when their ID was been deleted from our system.
### Are data deletions logged?
Yes, in the ID verification details timeline you can see the exact time of when the customers data was deleted for that ID check.
### Will archiving an ID check also delete data?
No, [archiving an ID check](./archiving-id-checks.md) will just filter the check from your main ID checks view by default. Archiving doesn't have any affect on customer data.
---
// File: for-merchants/downloading-customer-photos
# Downloading customer photos
You can download individual photos from any completed ID check directly from the Real ID dashboard.
## Available photos
All photos submitted during the ID verification process are available for download, including:
- **ID photo** - The front of the customer's government-issued ID (driver's license, passport, etc.)
- **Back of ID** - The back of the ID document, if required by your [verification rules](../rules.md)
- **Headshot/selfie** - The customer's face photo used for [face matching](../rules/face-match.md)
- **Proof of address** - Utility bills or other documents submitted for [address verification](../rules/proof-of-address.md)
- **Additional documentation** - Any other required documents such as firearms licenses or permits
- **Signatures** - Electronic signatures captured during the [eSignature step](../rules/capturing-e-signatures.md)
## How to download photos
To download a photo from an ID check:
1. Open the ID check from your [dashboard](./viewing-id-checks.md)
2. Scroll to the photo you want to download
3. Click the **Download** button below the photo

The photo will download directly to your device.
## Downloading photos via the API
You can also retrieve photos programmatically using the [REST API](../api/checks.mdx). When fetching an ID check, include the `withPhotos` query parameter:
```
GET https://real-id.getverdict.com/api/v1/checks/{{checkId}}?withPhotos=true
```
All photos will be returned as short-lived URLs in the API response under the `photos` key. These URLs expire after a short period for security purposes.
See the [Checks API documentation](../api/checks.mdx#retrieve-an-id-check) for full details on authentication and response format.
:::warning Data security responsibility
When you download customer photos, you become responsible for:
- **Secure storage** - Maintaining appropriate security measures to protect the downloaded PII
- **Access control** - Limiting who can view the downloaded photos
- **Data deletion requests** - Fulfilling any GDPR, CCPA, or other legal requests to delete the downloaded copies
- **Compliance** - Ensuring your handling of the data meets all applicable regulations
Real ID securely stores customer data on your behalf. We recommend only downloading photos when absolutely necessary for your business processes.
:::
---
// File: for-merchants/id-check-notifications
# ID Verification Notifications
In addition to updating customer accounts and orders in real time, Real ID will also send you emails as customers verify their IDs. You'll be notified when customers successfully pass, or fail to pass automatically. This way, you have a chance to [review the ID details](./viewing-id-checks.md) before fulfillment, and [can even override results](./overridding-results.md).
## Which email address is used?
For Shopify merchants, Real ID will use your contact email for your store to deliver email notifications. If you're using WooCommerce, your email address used for your [billing account](../woocommerce/activation.md) is the default.
:::info Fallback email behavior
If no team email addresses are configured in the notification settings, Real ID will automatically fall back to your store's contact email address. This ensures you always receive important ID verification notifications even if no specific team emails are set up.
:::
## Changing your email addresses for customer ID verification notifications
You can change which email address receives these notifications. For example, you may wish to delegate all ID verification tasks to a specific staff member, or decide to set up a specific email inbox for ID verification related processing.
To change your email addresses, open the **Settings** area of the plugin. Then select the **Notifications** menu tab.
Then open the **For your Team** section of the notifications settings.
Here is where you can manage the notifications for your team. You can change the email address, or define multiple email addresses that should be notified.

Don't forget to click **Save** to apply any changes you make.
## Controlling which email notifications you receive
You can choose exactly which types of email notifications your team receives. This allows you to reduce inbox noise by disabling notifications you don't need while keeping the ones that matter most to your workflow.
In the **For your Team** section of your notification settings, you'll find checkboxes for each notification type:
| Notification | Description |
|---|---|
| **ID verification completed** | Sent when a customer successfully passes ID verification. |
| **ID verification failed** | Sent when a customer fails automatic verification and needs manual review. |
| **Manually approved** | Sent when a staff member manually approves an ID check. |
| **Underage customer detected** | Sent when a customer is flagged as underage based on your age requirements. |
All notification types are enabled by default. Simply uncheck any notification type you'd like to stop receiving, and click **Save**.
:::tip
If you're only interested in knowing when an ID check needs manual review, you can disable the "ID verification completed" notification and keep the rest enabled. This way you'll only be notified when action is needed from your team.
:::
---
// File: for-merchants/interpreting-results
# Interpreting the ID check results
## Overall verdict
Real ID uses a combination of confidence scores from A.I. models, computer vision and [your rules](../rules.md) to determine if an ID check is considered a pass or fail.
## Confidence Scores

### ID photo quality
### Face photo quality
### Face match
## Extracted ID fields
### Name
### Address
### Document Type
### Birth Date
### Expiration Date
### Issue Date
### Class
## ID photos
## Signals
## Events Timeline
---
// File: for-merchants/managing-staff-permissions
# Setting up Staff Permissions
You can control which of your staff can view ID checks, override their results, or modify settings like setting up automatic ID check triggers.
To get started, first open up the **Settings** area in the app, then in the top menu select the **Staff** tab.
You should see a table of staff members and their current permissions.

:::info
This feature is only available to the Shopify version of Real ID at this time.
If you require this for your WooCommerce store or another platform, [please let us know](/contact).
:::
## Choosing permissions for a staff member
Real ID offers four permissions for each staff member:
* `View ID checks` - grants the ability to open ID checks, view the captured photos and the extracted information from them.
* `Manage ID checks` - grants the ability to manually approve or reject ID checks, or delete ID check data.
* `Manage Settings` - grants the ability to alter Real ID settings, including the ability to set up triggers, branding, etc.
* `Manage Staff` - grants the ability to change the permissions on other accounts.
## Default permissions for new staff
By default new staff members will always be granted the `View ID checks`, `Manage ID checks` and `Manage Settings` permissions. Only the account owner will be granted the `Manage Staff` permission.
That means that staff that open the app initially will be able to view ID checks, manually approve or reject them or change Real ID settings.
## Restricting staff to only process ID checks
If you need to restrict certain staff members to only process ID checks, and not have the ability to update settings, then enable `View ID checks` and `Manage ID checks` only:

## Allowing a staff member to manage other staff permissions
You can promote a staff member to manage other staff's permissions by adding the `Manage Staff` permission to their account:

## Not all staff appearing in the permissions list
Unfortunately Shopify does not allow apps to view staff lists. You can only manage staff permissions of staff that have opened the app at least once.
Once a staff member opens Real ID, the app will create an account for that staff member and it will appear in this permissions list.
By default, new staff members are assigned `View ID checks`, `Manage ID checks` and `Manage Settings` permissions.
---
// File: for-merchants/overridding-results
# Overriding ID check results
Occasionally you may want to override Real ID's results on an ID submission. You can easily do this from the Real ID dashboard.
From the app you can open the ID check details, at the very top of the ID check will be a menu of buttons.
Here you can choose to manually override the ID check results by either approving or rejecting the results.
## Manually approving an ID check
You can manually approve an ID check at any time, including before the customer has actually submitted photos or after they've failed their ID check.
To manually approve an ID check, click the **Approve Check** at the top of the page from within the ID check details page:

You'll be asked to confirm before the check is approved:

Then the check will be considered passed throughout Real ID. This includes if you have ID verification required [before viewing your store](../flows/before-viewing-store.md), or [before checkout is required](../flows/before-checkout.mdx).
**Email Notification**: When a staff member manually approves an ID check, your store's contact email addresses will automatically receive a notification email. The email will include contextual information such as the customer's name and order ID when available, helping you track manual approval activities across your team. You can [customize which email addresses receive these notifications](./id-check-notifications.md#changing-your-email-addresses-for-customer-id-verification-notifications) in your notification settings.
:::caution
If you manually approve an ID check that's in progress or doesn't have any photos submitted yet at all - it's will lock the customer from completing the ID check.
The ID check will be shown as completed to the customer.
:::
## Manually rejecting an ID check
You can also manually reject an ID check at any time, even if it's been passed or manually approved.
To manually reject an ID check, open the **More actions** menu in the top right in the ID check, and then select **Reject Check**:

You'll be asked to confirm this action:

Then the ID check will be considered failed throughout Real ID. This includes tags, metafields and notes left on the order and customer profile.
:::caution
If you manually reject an ID check that's in progress or doesn't have any photos submitted yet at all - it will lock the customer from completing the ID check.
The ID check will be shown as failed to the customer.
:::
---
// File: for-merchants/retrying-id-checks
# Retrying ID checks
Sometimes a customer fails their ID check and you'd like to give them another chance — for example, they used a document that isn't supported, their ID was damaged, or the photos came out too poorly to read.
Real ID handles this in two ways: **soft retries** during a single check, and **hard retries** that start a fresh check.
## Soft retries (automatic)
Within a single ID check, customers are given **3 attempts per stage** to capture a high quality, readable photo. If a customer requires both an ID photo and a portrait photo, they get 3 attempts for each.
Soft retries do not incur extra charges — you're only charged once for the entire check, no matter how many soft attempts the customer uses. If a customer uses all 3 attempts in a stage, they're allowed to continue on to the next stage so they can still complete the flow.
[Learn more about soft retries](../id-check-process.md#maximum-soft-retries).
## Hard retries (a fresh ID check)
A **hard retry** lets a customer start over with a brand new ID check after their previous one is complete — useful when the original check went [In Review](../id-check-process.md#in-review) or was [manually rejected](../id-check-process.md#manually-rejected) and you want to let the customer try again.
Because a hard retry creates a new ID check, it is treated as a separate check throughout Real ID.
### Sending a hard retry
You can send the customer a fresh ID check the same way you'd [send any ID check](../sending-an-id-check.md):
* Open the customer or order in the Real ID dashboard and send a new ID check, or
* On platforms that support it, enable [automatic retries](../rules/automatic-retries.md) so Real ID sends a new check automatically when a customer fails.
The customer receives a new ID check link and starts the flow again from the beginning, with a fresh set of soft retries.
:::note
A hard retry is a **new** ID check. Unlike soft retries, a new check may be billable depending on your plan. Review the original submission first — in many cases [overriding the result](./overridding-results.md) is faster than asking the customer to start over.
:::
## Which should I use?
| Situation | Use |
| --- | --- |
| Customer is mid-check and a stage failed | Soft retries (automatic, no action needed) |
| Check is complete but you believe the ID is actually valid | [Override the result](./overridding-results.md) |
| Check is complete and you want the customer to submit again from scratch | Hard retry |
---
// File: for-merchants/viewing-id-checks
# Viewing ID checks
You can view all of your customers ID checks in the Real ID app directly from the home page.
This is a real time dashboard of all past and current ID checks for your customers.
## Filtering ID checks
Real ID comes with easy to use filters to quickly exclude or include ID checks in the results by **status**, of view **archived** checks.
### By status
You can filter ID checks by their current status. By default, all ID checks are shown but if you need to filter only in progress checks, then select the **In Progress* filter:

The available statuses are:
* `In Progress` - ID checks where the customer still needs to submit one or more photos to finish their check
* `In Review` - ID checks where the customer was not able to be automatically verified, and they are ready for manual review
* `Verified` - ID checks where the customer was either automatically verified or their ID was [manually approved](./overridding-results.md) by a staff member on your team.
* `Failed` - ID checks where the ID was [manually rejected](./overridding-results.md) by a staff member on your team.
### Archived checks
You can archive old ID checks to mark them as processed or to help clean up your ID checks dashboard.
Archived ID checks are not deleted, you'll still be able to access photos & data, but they're just not within the home page by default.
To view archived ID checks, select the **Archived** checkbox to only display archived checks:

## Searching for a specific ID check
In the search bar on the homepage or at the top of the navigation bar, you can quickly search for specific ID checks by the customer's name, email address, phone number or even by the order number.

Real ID will automatically apply your search instantly, and the results in the home page will only show those ID checks.
## Viewing an ID check
To open a specific ID check that you've either filtered or searched for, simply check on the result:

:::tip View ID checks directly in your orders and customers pages
If you're using Shopify as your eCommerce platform, you can also view your customer's ID checks without leaving your Shopify dashboard.
[Use our Shopify Admin Blocks](../shopify/admin-extensions.md) to add the ID check results directly to your orders and/or customer pages to view ID checks without leaving Shopify.
:::
---
// File: getting-started/wizard
import GettingStartedWizard from '@site/src/components/GettingStartedWizard';
# Getting Started with Real ID
Welcome to Real ID! This interactive wizard will guide you through setting up ID verification for your store.
---
## Need Help?
If you have questions or run into issues during setup:
- **[FAQs](/help/docs/faqs)** - Common questions and answers
- **[Contact Support](/help/contact)** - Get help from our team
- **[Test Mode](/help/docs/getting-started/test-mode)** - Try verification in a sandbox environment
---
// File: getting-started/_steps/_age-restriction
# Configure Age Verification
Since you selected age verification as your use case, let's set up the age requirements for your store.
## Access Age Settings
Navigate to **Settings** → **Rules** → **Age Requirements** in your Real ID dashboard.
## Set Minimum Age
Choose the minimum age customers must be to pass verification:
### Standard Options
- **18+** - Common for adult products, gambling, certain media
- **21+** - Required for alcohol, cannabis in most U.S. states
### Custom Age
If you need a different age requirement, select **Custom** and enter your specific age (e.g., 25 for car rentals).

## Location-Based Age Rules
For U.S. and Canadian tobacco/cannabis merchants, age requirements vary by state or province.
### Enable Location-Based Rules
1. Enable **U.S./Canadian Tobacco Age Requirements**
2. Real ID will automatically apply the correct minimum age based on the customer's location
| Region | Tobacco Age |
|--------|-------------|
| Most U.S. States | 21+ |
| Alberta, Canada | 18+ |
| Ontario, Canada | 19+ |
| British Columbia | 19+ |
:::note Before Checkout Flow
If using the before-checkout flow, the age requirement is based on the province/state shown on the customer's ID document (since there's no shipping address yet).
:::
## How Age Verification Works
1. Real ID reads the **Date of Birth** from the verified ID document
2. The customer's age is calculated based on the current date
3. If the customer meets your minimum age requirement, the check passes
4. If the customer is underage, the check automatically fails
## What Happens When Someone Fails?
When a customer fails age verification:
1. The ID check is marked as **Failed**
2. The customer is notified they didn't pass verification
3. Your staff can review the submission in the Real ID dashboard
4. You can choose to manually approve if there was an error
## Products and Categories
Age verification applies to all ID checks, regardless of which trigger started them. If you only want age verification for certain products:
1. Create a specific collection/category for age-restricted products
2. Configure your triggers to only verify orders with those products
3. Age requirements will apply to those verifications
[Learn more about product-based triggers →](/help/docs/triggers/specific-products)
## Next Steps
Now let's configure how verification results sync back to your store.
---
// File: getting-started/_steps/_branding
# Customize Your Branding
Make the ID verification experience match your brand. Customers are more likely to complete verification when it looks familiar and trustworthy.
## Access Branding Settings
Navigate to **Settings** → **Appearance** in your Real ID dashboard.
## Upload Your Logo
Your logo appears in:
- The ID verification flow
- Email notifications
- SMS message links
To add your logo:
1. Scroll to the **Logo** section
2. Drag and drop your logo file, or click to browse
3. Click **Save**

:::tip Logo Tips
- Use a transparent PNG for best results
- Your logo will be automatically resized for different devices
- Square or horizontal logos work best
:::
## Set Your Colors
Customize the color scheme to match your brand:
### Primary Color
The background color used throughout the verification flow and emails.
:::tip
Use a neutral or light color as your primary color. This helps the action buttons stand out.
:::
### Button Color
The color for call-to-action buttons like "Start Verification" and "Continue".
:::tip
Use a darker, contrasting color for buttons. The button text is white, so darker backgrounds improve readability.
:::

## Preview Your Changes
After saving, click **Preview** to see how the verification flow will look to your customers. Test on both desktop and mobile views.
## Custom Content
You can also customize the text shown to customers:
1. Go to **Settings** → **Appearance** → **Content**
2. Edit the welcome message, instructions, and completion text
3. Click **Save**
[Learn more about customizing content →](/help/docs/theming/customize-content)
## Next Steps
Next, we'll set up email delivery so verification requests come from your domain.
---
// File: getting-started/_steps/_custom-email
# Set Up Email Delivery
ID verification requests are sent to customers via email. For the best customer experience and deliverability, configure emails to come from your own domain.
## Why Use Your Email Address?
- **Brand recognition** - Customers trust emails from your domain
- **Better deliverability** - Reduces spam filtering
- **Professional appearance** - Consistent with your other communications
## Option 1: Use Your Email Domain (Recommended)
Send verification emails from an address like `verify@yourdomain.com`.
### Step 1: Access Email Settings
Go to **Settings** → **Appearance** → **Email** in your Real ID dashboard.
### Step 2: Add Your Email Address
Enter the email address you want to send from (e.g., `verify@yourdomain.com` or `support@yourdomain.com`).
### Step 3: Verify Domain Ownership
To prove you own the domain, you'll need to add DNS records:
1. Click **Generate DNS Records**
2. Add the provided DKIM and SPF records to your domain's DNS settings
3. Click **Verify** once the records are added
:::info DNS Propagation
DNS changes can take up to 48 hours to propagate, though most complete within a few hours.
:::
### Step 4: Test Delivery
Send a test email to yourself to verify everything is working correctly.
## Option 2: Use Real ID's Email
If you don't want to set up custom email, Real ID can send emails from our domain. These emails will still include your logo and branding.
Emails will come from: `noreply@getverdict.com`
## Email Customization
Regardless of which option you choose, you can customize:
- **Subject line** - The email subject customers see
- **Preheader text** - Preview text shown in email clients
- **Body content** - The main message explaining why verification is needed
- **Button text** - The call-to-action text
Go to **Settings** → **Appearance** → **Email Content** to customize these.
## SMS Notifications
In addition to email, Real ID can send verification links via SMS to customers who provide a phone number.
1. Go to **Settings** → **Notifications**
2. Enable **SMS Notifications**
3. Customize the SMS message if desired
:::tip
SMS has higher open rates than email. Enable both for the best completion rates.
:::
## Next Steps
Your branding and email are configured! Let's continue with additional settings based on your use case.
---
// File: getting-started/_steps/_feedback-bigcommerce
# Order Feedback in BigCommerce
Real ID syncs verification results back to your BigCommerce store, letting you track order status and manage fulfillment.
## Order Status Syncing
Real ID can automatically update BigCommerce order statuses based on verification:
### Configure Status Mapping
1. Log in to your Real ID dashboard
2. Go to **Settings** → **Order Statuses**
3. Map verification events to BigCommerce statuses:
| Verification Event | Suggested BigCommerce Status |
|-------------------|------------------------------|
| Verification pending | Awaiting Fulfillment |
| Verification passed | Shipped or Processing |
| Verification failed | Cancelled or Manual Review |
:::tip Custom Statuses
Create custom order statuses in BigCommerce like "Awaiting ID Verification" for clearer order management.
:::
[Learn more about order status syncing →](/help/docs/bigcommerce/order-statuses)
## Viewing ID Checks
### From Real ID Dashboard
1. Log in to your Real ID dashboard
2. View all checks on the **ID Checks** page
3. Filter by status, search by order number or customer email
### From BigCommerce Orders
When viewing an order in BigCommerce admin, you can:
1. Click the order number to view details
2. Look for the Real ID status in order notes/comments
3. Click the link to view the full verification in Real ID
## Customer Verification History
Real ID tracks which customers have been verified:
- Verified customers won't be prompted again on future orders
- View a customer's verification history in the Real ID dashboard
## Notifications
### Staff Notifications
Configure email alerts for your team:
1. Go to **Settings** → **Notifications** in Real ID
2. Add email addresses for alerts
3. Choose which events trigger notifications:
- Verification started
- Verification completed (passed)
- Verification failed
- Verification requires review
### Customer Notifications
Customers receive automatic notifications:
- Email when verification is requested
- SMS if phone number is provided
- Confirmation when verification completes
## Webhooks
For advanced integrations, set up webhooks to receive real-time events:
1. Go to **Settings** → **Webhooks** in your Real ID dashboard
2. Add your endpoint URL
3. Select which events to receive
Webhook events include:
- `check.created` - New verification started
- `check.approved` - Customer passed verification
- `check.failed` - Customer failed verification
- `check.expired` - Verification link expired
[View webhook documentation →](/help/docs/api/webhooks)
## Reporting
View verification analytics in your Real ID dashboard:
- Total verifications by status
- Approval/failure rates
- Average completion time
- Common failure reasons
## Next Steps
Your BigCommerce integration is configured! Continue to the final step to learn about order holding for unverified orders.
---
// File: getting-started/_steps/_feedback-custom
# Handling Verification Results
With API integration, you have full control over how to receive and process verification results.
## Receiving Results via Webhooks
Webhooks are the recommended way to receive real-time verification updates.
### Configure Webhooks
1. Go to **Settings** → **Webhooks** in your Real ID dashboard
2. Add your endpoint URL (e.g., `https://yourapp.com/webhooks/realid`)
3. Select which events to receive
### Webhook Events
| Event | Description |
|-------|-------------|
| `check.created` | A new ID check was created |
| `check.pending` | Customer started verification |
| `check.approved` | Customer passed verification |
| `check.failed` | Customer failed verification |
| `check.expired` | Verification link expired |
| `check.manual_review` | Check requires manual review |
### Webhook Payload Example
```json
{
"id": "evt_abc123",
"type": "check.approved",
"created": 1699900000,
"data": {
"checkId": "chk_xyz789",
"orderId": "12345",
"orderNumber": "ORD-12345",
"status": "approved",
"customer": {
"email": "customer@example.com",
"name": "John Doe"
},
"extractedData": {
"firstName": "John",
"lastName": "Doe",
"dateOfBirth": "1990-05-15",
"address": "123 Main St, City, ST 12345"
},
"completedAt": "2024-01-15T10:30:00Z"
}
}
```
### Handling Webhooks
```javascript
app.post('/webhooks/realid', async (req, res) => {
// Verify webhook signature
const signature = req.headers['x-realid-signature'];
if (!verifySignature(req.body, signature)) {
return res.status(401).send('Invalid signature');
}
const event = req.body;
switch (event.type) {
case 'check.approved':
await handleApproved(event.data);
break;
case 'check.failed':
await handleFailed(event.data);
break;
default:
console.log('Unhandled event type:', event.type);
}
res.sendStatus(200);
});
async function handleApproved(data) {
// Update your database
await db.orders.update({
where: { id: data.orderId },
data: {
idVerified: true,
verifiedAt: data.completedAt,
verifiedName: data.extractedData.firstName + ' ' + data.extractedData.lastName
}
});
// Continue with order fulfillment
await fulfillOrder(data.orderId);
}
async function handleFailed(data) {
// Hold the order
await db.orders.update({
where: { id: data.orderId },
data: { status: 'on_hold', holdReason: 'ID verification failed' }
});
// Notify staff
await sendSlackNotification(`Order ${data.orderNumber} failed ID verification`);
}
```
## Polling the API
If webhooks aren't suitable for your architecture, you can poll the check status:
```javascript
async function pollCheckStatus(checkId, maxAttempts = 60) {
for (let attempt = 0; attempt < maxAttempts; attempt++) {
const response = await fetch(`https://api.getverdict.com/v1/checks/${checkId}`, {
headers: { 'Authorization': `Bearer ${API_KEY}` }
});
const check = await response.json();
if (check.status !== 'pending') {
return check; // Verification complete
}
// Wait before next poll
await new Promise(resolve => setTimeout(resolve, 10000)); // 10 seconds
}
throw new Error('Polling timeout - verification not completed');
}
```
## Storing Verification Data
Store relevant verification data in your database for:
- Compliance records
- Customer history
- Analytics
```javascript
// Example database schema
const verificationSchema = {
checkId: String, // Real ID check ID
orderId: String, // Your order ID
customerId: String, // Your customer ID
status: String, // approved, failed, pending
verifiedAt: Date,
extractedData: {
name: String,
dateOfBirth: Date,
address: String,
documentType: String // drivers_license, passport, etc.
},
rawResponse: Object // Full API response for records
};
```
## JavaScript SDK Events
If using the JS SDK for client-side integration, handle events directly:
```javascript
RealID.verify({
email: customerEmail,
orderId: orderId,
onComplete: (result) => {
if (result.status === 'approved') {
// Update UI
showSuccess('Identity verified!');
// Notify your server
fetch('/api/verification-complete', {
method: 'POST',
body: JSON.stringify({ checkId: result.checkId, orderId })
});
}
},
onError: (error) => {
showError('Verification failed: ' + error.message);
}
});
```
## Next Steps
Your API integration is configured! Review the complete [API documentation](/help/docs/api/checks) for additional endpoints and options.
---
// File: getting-started/_steps/_feedback-shopify
# Tags & Feedback in Shopify
Real ID automatically syncs verification results back to your Shopify store. This lets you filter orders, automate workflows, and keep your team informed.
## Order Tags
Real ID adds tags to orders based on verification status:
| Tag | Meaning |
|-----|---------|
| `ID check pending` | Customer has been sent a verification request |
| `ID check completed` | Customer passed verification |
| `ID verification failed` | Customer failed verification |
### Using Tags to Filter Orders
1. Go to **Orders** in Shopify admin
2. Click **More filters** → **Tagged with**
3. Select the tag you want to filter by
:::tip Create a Saved View
Create saved order views like "Pending ID Verification" to quickly see orders needing attention.
[Learn how →](/help/docs/shopify/setting-up-an-order-view)
:::
## Customer Tags
Similar tags are added to customer profiles:
- `ID check completed` - Customer has been verified
- Verified customers won't be prompted again on future orders
## Order Notes
Real ID can add notes to orders with verification details:
1. Go to **Settings** → **Shopify** → **Notes**
2. Enable **Add verification notes to orders**
3. Choose what information to include
[Learn more about order notes →](/help/docs/shopify/notes)
## Metafields
For programmatic access to verification data, Real ID can populate metafields on orders and customers:
- Verification status
- Check ID (for API lookups)
- Completion timestamp
- Extracted ID data (name, DOB, etc.)
[Learn more about metafields →](/help/docs/shopify/metafields)
## Shopify Flow Integration
Automate actions based on verification results using Shopify Flow:
### Example Flows
**Auto-fulfill verified orders:**
- Trigger: Order tag added `ID check completed`
- Action: Fulfill order
**Alert staff about failed verifications:**
- Trigger: Order tag added `ID verification failed`
- Action: Send internal email
**Cancel unverified orders after 48 hours:**
- Trigger: Order created
- Condition: After 48 hours, tag doesn't include `ID check completed`
- Action: Cancel order
[Set up Shopify Flow integration →](/help/docs/shopify/flow)
## Admin Extension
View ID check status directly on order and customer pages without leaving Shopify admin:
1. Open any order with an ID check
2. See the verification status, photos, and extracted data in the sidebar
[Learn more about the admin extension →](/help/docs/shopify/admin-extensions)
## Next Steps
Your Shopify integration is configured! Continue to the final step to learn about order holding for unverified orders.
---
// File: getting-started/_steps/_feedback-woocommerce
# Metadata & Feedback in WooCommerce
Real ID automatically syncs verification results back to your WooCommerce store. This lets you filter orders, automate workflows, and keep your team informed.
## Order Metadata
Real ID adds metadata to orders with verification details:
| Meta Key | Description |
|----------|-------------|
| `_realid_check_status` | Current status (pending, approved, failed) |
| `_realid_check_id` | Unique ID check identifier |
| `_realid_check_url` | Link to view the check in Real ID |
| `_realid_verified_at` | Timestamp when verification completed |
### Viewing Metadata
1. Open an order in WooCommerce
2. Look for the **Real ID** metabox in the sidebar
3. Or view under **Custom Fields** at the bottom
## Customer Metadata
Verified customer information is stored on user profiles:
- `realid_verified` - Whether customer has been verified
- `realid_verified_at` - Verification timestamp
- `realid_check_id` - Reference to the verification check
This metadata is used to skip verification for repeat customers.
## Order Status Syncing
WooCommerce order statuses can automatically change based on verification:
1. Go to **Real ID** → **Settings** → **Order Statuses**
2. Configure status mapping:
| Verification Event | Suggested WooCommerce Status |
|-------------------|------------------------------|
| Verification pending | On Hold |
| Verification passed | Processing |
| Verification failed | On Hold or Cancelled |
:::tip
Use a custom order status like "Awaiting ID Verification" for clearer order management.
:::
[Learn more about order statuses →](/help/docs/woocommerce/order-statuses)
## Webhooks
Receive real-time notifications when verification events occur:
1. Go to **WooCommerce** → **Settings** → **Advanced** → **Webhooks**
2. Create webhooks for Real ID events
Or use WordPress hooks in your theme/plugin:
```php
// Action when verification completes
add_action('realid_check_completed', function($check_id, $order_id, $status) {
$order = wc_get_order($order_id);
if ($status === 'approved') {
$order->update_status('processing');
} else {
// Send notification to admin
wp_mail(get_option('admin_email'), 'ID Verification Failed', "Order #{$order_id} failed verification");
}
}, 10, 3);
```
[Learn more about hooks →](/help/docs/woocommerce/hooks)
## Shortcodes
Display verification status on your site using shortcodes:
```
[realid_status] - Show current user's verification status
[realid_verify] - Display a verification button
```
[Learn more about shortcodes →](/help/docs/woocommerce/shortcodes)
## Viewing ID Checks
Access all ID checks from the WordPress admin:
1. Go to **Real ID** in the WordPress sidebar
2. View all checks, filter by status, search by order number
## Logs
Debug issues using the built-in logging:
1. Go to **Real ID** → **Logs**
2. View API calls, webhook events, and errors
[Learn more about logs →](/help/docs/woocommerce/logs)
## Next Steps
Your WooCommerce integration is configured! Continue to the final step to learn about order holding for unverified orders.
---
// File: getting-started/_steps/_install-bigcommerce
# Install the BigCommerce App
Real ID integrates with your BigCommerce store through the BigCommerce App Marketplace.
## Step 1: Install from the Marketplace
Visit the BigCommerce App Marketplace and search for "Real ID", or click the button below:
Install Real ID on BigCommerce
## Step 2: Authorize the App
After clicking install, you'll be asked to authorize Real ID. This allows us to:
- Read order and customer information
- Update order statuses based on verification results
- Display verification status in your dashboard
Click **Confirm** to continue.
## Step 3: Complete Account Setup
After authorization, you'll be redirected to the Real ID dashboard. If you're new to Real ID, you'll be prompted to:
1. Create your Real ID account (or sign in if you already have one)
2. Connect your BigCommerce store
3. Choose your subscription plan
## Step 4: Add the Verification Script
For after-checkout verification, you'll need to add our script to your order confirmation page:
1. In BigCommerce, go to **Storefront** → **Script Manager**
2. Click **Create a Script**
3. Configure the script:
- **Name**: Real ID Verification
- **Location**: Footer
- **Pages**: Order Confirmation
- **Script type**: Script tag
4. Paste the script provided in your Real ID dashboard
:::tip
The exact script code is available in your Real ID dashboard under **Settings** → **Installation**.
:::
## Next Steps
In the following steps, we'll configure:
- When to trigger ID verification
- How ID checks appear to your customers
- Order status syncing
---
// File: getting-started/_steps/_install-custom
# Set Up API Access
For custom platforms, Real ID provides a REST API and JavaScript SDK for full integration flexibility.
## Step 1: Create Your Account
First, sign up for a Real ID account:
Create Account
## Step 2: Get Your API Credentials
After signing up:
1. Log in to your Real ID dashboard
2. Navigate to **Settings** → **API**
3. Copy your **API Key** and **Secret**
:::caution Keep your credentials secure
Your API key and secret provide full access to your Real ID account. Never expose them in client-side code or public repositories.
:::
## Step 3: Choose Your Integration Method
### REST API
Use our REST API for server-to-server integration:
```bash
# Create an ID check
curl -X POST https://api.getverdict.com/v1/checks \
-H "Authorization: Bearer YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{
"email": "customer@example.com",
"name": "John Doe",
"orderId": "12345"
}'
```
[View full API documentation →](/help/docs/api/checks)
### JavaScript SDK
For web applications, use our JavaScript SDK:
```html
```
[View JS SDK documentation →](/help/docs/js)
## Step 4: Configure Webhooks (Recommended)
Set up webhooks to receive real-time notifications when verifications complete:
1. Go to **Settings** → **Webhooks** in your dashboard
2. Add your webhook endpoint URL
3. Select which events to receive
[View webhook documentation →](/help/docs/api/webhooks)
## Next Steps
In the following steps, we'll cover:
- Triggering ID verification from your application
- Customizing the verification experience
- Handling verification results
---
// File: getting-started/_steps/_install-shopify
# Install the Shopify App
Real ID integrates directly with your Shopify store through the Shopify App Store.
## Step 1: Install from the App Store
Click the button below to install Real ID from the Shopify App Store:
Install Real ID on Shopify
Or search for "Real ID" in the Shopify App Store from your admin dashboard.
## Step 2: Authorize the App
After clicking install, you'll be asked to authorize Real ID to access your store. This allows us to:
- Read order and customer information
- Add tags and metafields to orders and customers
- Display ID checks in your admin
Click **Install** to continue.
## Step 3: Complete Setup
After authorization, you'll be redirected to the Real ID dashboard within your Shopify admin. You're now ready to configure your ID verification settings!
:::tip
Real ID offers a free trial so you can test the integration before committing. No credit card required.
:::
## Next Steps
In the following steps, we'll configure:
- When to trigger ID verification
- How ID checks appear to your customers
- What happens when verification completes or fails
---
// File: getting-started/_steps/_install-woocommerce
# Install the WooCommerce Plugin
Real ID integrates with WooCommerce through a WordPress plugin.
## Step 1: Download the Plugin
Get the Real ID plugin from our website:
Download WooCommerce Plugin
You'll receive a `.zip` file containing the plugin.
## Step 2: Upload to WordPress
1. Log in to your WordPress admin dashboard
2. Navigate to **Plugins** → **Add New**
3. Click **Upload Plugin** at the top of the page
4. Choose the downloaded `.zip` file and click **Install Now**

## Step 3: Activate the Plugin
After the upload completes, click **Activate Plugin**.
## Step 4: Enter Your License Key
1. In your WordPress admin, go to **Real ID** in the sidebar
2. Enter your license key (received via email after purchase)
3. Click **Activate License**
:::info
Don't have a license key? [Contact us](https://getverdict.com/contact) to get started with a free trial.
:::
## Step 5: Verify Connection
Once activated, you should see a green "Connected" status in the Real ID settings. This means your store is ready to process ID verifications.
## Next Steps
In the following steps, we'll configure:
- When to trigger ID verification
- How ID checks appear to your customers
- Order status syncing with verification results
---
// File: getting-started/_steps/_order-holding-bigcommerce
# Order Holding in BigCommerce
With the after-checkout flow, customers complete their purchase before verifying their ID. Configure BigCommerce to hold orders until verification completes.
## Why Hold Orders?
- **Fraud prevention** - Don't ship until identity is confirmed
- **Age compliance** - Ensure customers are legal age before fulfillment
- **Chargeback protection** - Verified orders have evidence if disputed
## Order Status Workflow
The recommended workflow uses BigCommerce order statuses:
| Order Status | When Used |
|--------------|-----------|
| **Awaiting Fulfillment** | Order placed, awaiting ID verification |
| **Awaiting Shipment** | ID verification passed, ready to ship |
| **Cancelled** | ID verification failed (optional) |
### Configure Automatic Status Changes
1. Log in to your Real ID dashboard
2. Go to **Settings** → **Order Statuses**
3. Set up the mapping:
**When verification is requested:**
- Set order status to: `Awaiting Fulfillment`
**When verification passes:**
- Set order status to: `Awaiting Shipment`
**When verification fails:**
- Set order status to: `Manual Verification Required` or `Cancelled`
[Learn more about BigCommerce order statuses →](/help/docs/bigcommerce/order-statuses)
## Custom Order Status
For clearer order management, consider creating a custom status in BigCommerce:
1. Go to BigCommerce admin → **Orders** → **Order Statuses**
2. Click **Add Custom Status**
3. Name it "Awaiting ID Verification"
4. Select this status in Real ID settings
## Fulfillment Integration
If you use a fulfillment app or 3PL:
1. Configure it to only process orders with status `Awaiting Shipment`
2. Orders with status `Awaiting Fulfillment` will be held
Most fulfillment integrations support status-based filtering.
## Handling Failed Verifications
When a customer fails verification:
1. The order status changes based on your settings
2. Review the submission in Real ID
3. Options:
- **Approve manually** if the failure was a technical error
- **Contact the customer** to retry verification
- **Refund and cancel** if you can't verify
### Staff Notifications
Configure email alerts for failed verifications:
1. Go to **Settings** → **Notifications** in Real ID
2. Add team email addresses
3. Enable notifications for failed verifications
## Automatic Reminders
If customers don't complete verification, Real ID can send automatic reminders:
1. Go to **Settings** → **Notifications** in Real ID
2. Enable **Automatic reminders**
3. Configure reminder timing (e.g., 2 hours, 24 hours after checkout)
[Learn more about automatic reminders →](/help/docs/for-merchants/automatic-id-check-reminders)
## Dashboard Visibility
View order verification status in your BigCommerce dashboard:
1. Go to **Orders** in BigCommerce admin
2. Filter by order status to see pending verifications
3. Click an order to see verification details in notes
Or view all verifications in the Real ID dashboard with full details.
## Setup Complete!
You've configured Real ID for your BigCommerce store. Here's a summary:
- **Platform**: BigCommerce
- **Flow**: After Checkout
- **Triggers**: Configured based on your needs
- **Branding**: Customized with your logo and colors
- **Feedback**: Order status syncing
- **Order Holding**: Using order status mapping
### What's Next?
- [Send a test verification](/help/docs/getting-started/test-mode) to yourself
- [Review an ID check](/help/docs/bigcommerce/viewing-ids) in the dashboard
- Explore [additional rules](/help/docs/rules/face-match) like biometric face matching
---
// File: getting-started/_steps/_order-holding-shopify
# Order Holding in Shopify
With the after-checkout flow, customers complete their purchase before verifying their ID. You'll want to hold orders until verification completes to avoid shipping to unverified customers.
## Why Hold Orders?
- **Fraud prevention** - Don't ship until identity is confirmed
- **Age compliance** - Ensure customers are legal age before fulfillment
- **Chargeback protection** - Verified orders have evidence if disputed
## Automatic Order Holding
Real ID tags orders with their verification status. Use these tags to control fulfillment:
### Manual Workflow
1. Create a saved order view showing only verified orders:
- Filter: Tagged with `ID check completed`
2. Only fulfill orders from this view
### Using Shopify Flow
Automate order holding with Shopify Flow:
**Hold orders until verified:**
```
Trigger: Order created
Condition: Order triggers contain "ID verification"
Action: Add tag "Hold for ID verification"
```
**Release orders when verified:**
```
Trigger: Order tag added (ID check completed)
Action: Remove tag "Hold for ID verification"
```
**Auto-cancel unverified orders:**
```
Trigger: Order created
Wait: 48 hours
Condition: Order tags don't contain "ID check completed"
Action: Cancel order
```
[Set up Shopify Flow →](/help/docs/shopify/flow)
## Fulfillment Apps
If you use a fulfillment app or 3PL, configure it to:
1. Only process orders tagged `ID check completed`
2. Or exclude orders tagged `ID check pending`
Most fulfillment integrations support tag-based filtering.
## Payment Capture
If you use manual payment capture:
1. Configure Shopify to authorize (not capture) at checkout
2. Set up a Flow to capture payment when `ID check completed` tag is added
3. Void authorization if verification fails
## Staff Training
Ensure your team knows to:
1. Check for the `ID check completed` tag before packing orders
2. Review orders in Real ID before manual approval
3. Contact customers whose verification failed
## Handling Failed Verifications
When a customer fails verification:
1. The order is tagged `ID verification failed`
2. Review the submission in Real ID
3. Options:
- **Approve manually** if the failure was a technical error
- **Contact the customer** to retry verification
- **Refund and cancel** if you can't verify
## Automatic Reminders
If customers don't complete verification, Real ID can send automatic reminders:
1. Go to **Settings** → **Notifications**
2. Enable **Automatic reminders**
3. Configure reminder timing (e.g., 2 hours, 24 hours after checkout)
[Learn more about automatic reminders →](/help/docs/for-merchants/automatic-id-check-reminders)
## Setup Complete!
You've configured Real ID for your Shopify store. Here's a summary:
- **Platform**: Shopify
- **Flow**: After Checkout
- **Triggers**: Configured based on your needs
- **Branding**: Customized with your logo and colors
- **Feedback**: Tags and metafields syncing
- **Order Holding**: Using tags and/or Flow
### What's Next?
- [Send a test verification](/help/docs/getting-started/test-mode) to yourself
- [Review an ID check](/help/docs/for-merchants/viewing-id-checks) in the dashboard
- Explore [additional rules](/help/docs/rules/face-match) like biometric face matching
---
// File: getting-started/_steps/_order-holding-woocommerce
# Order Holding in WooCommerce
With the after-checkout flow, customers complete their purchase before verifying their ID. Configure WooCommerce to hold orders until verification completes.
## Why Hold Orders?
- **Fraud prevention** - Don't ship until identity is confirmed
- **Age compliance** - Ensure customers are legal age before fulfillment
- **Chargeback protection** - Verified orders have evidence if disputed
## Order Status Workflow
The recommended workflow uses WooCommerce order statuses:
| Order Status | When Used |
|--------------|-----------|
| **On Hold** | Order placed, awaiting ID verification |
| **Processing** | ID verification passed, ready to fulfill |
| **Cancelled** | ID verification failed (optional) |
### Configure Automatic Status Changes
1. Go to **Real ID** → **Settings** → **Order Statuses**
2. Set up the mapping:
**When verification is requested:**
- Set order status to: `On Hold`
**When verification passes:**
- Set order status to: `Processing`
**When verification fails:**
- Set order status to: `On Hold` (for manual review)
- Or: `Cancelled` (auto-cancel failed orders)

## Custom Order Status
For clearer order management, create a custom status:
### Add "Awaiting ID Verification" Status
Add this code to your theme's `functions.php`:
```php
// Register custom order status
function register_awaiting_verification_order_status() {
register_post_status('wc-awaiting-id', array(
'label' => 'Awaiting ID Verification',
'public' => true,
'exclude_from_search' => false,
'show_in_admin_all_list' => true,
'show_in_admin_status_list' => true,
'label_count' => _n_noop('Awaiting ID (%s)', 'Awaiting ID (%s)')
));
}
add_action('init', 'register_awaiting_verification_order_status');
// Add to order status list
function add_awaiting_verification_to_order_statuses($order_statuses) {
$new_statuses = array();
foreach ($order_statuses as $key => $status) {
$new_statuses[$key] = $status;
if ($key === 'wc-on-hold') {
$new_statuses['wc-awaiting-id'] = 'Awaiting ID Verification';
}
}
return $new_statuses;
}
add_filter('wc_order_statuses', 'add_awaiting_verification_to_order_statuses');
```
Then select this status in Real ID settings.
## Shipping Integration
If you use a shipping plugin or fulfillment service:
1. Configure it to only process orders with status `Processing`
2. Or exclude orders with status `On Hold` or `Awaiting ID Verification`
## Handling Failed Verifications
When a customer fails verification:
1. The order status changes based on your settings
2. Review the submission in Real ID
3. Options:
- **Approve manually** if the failure was a technical error
- **Contact the customer** to retry verification
- **Refund and cancel** if you can't verify
### Automatic Notifications
Set up email notifications for failed verifications:
```php
// Notify admin when verification fails
add_action('realid_check_failed', function($check_id, $order_id) {
$order = wc_get_order($order_id);
$admin_email = get_option('admin_email');
wp_mail(
$admin_email,
'ID Verification Failed - Order #' . $order->get_order_number(),
'Order #' . $order->get_order_number() . ' failed ID verification. Please review in Real ID.'
);
}, 10, 2);
```
## Automatic Reminders
If customers don't complete verification, Real ID can send automatic reminders:
1. Go to **Settings** → **Notifications** in Real ID
2. Enable **Automatic reminders**
3. Configure reminder timing (e.g., 2 hours, 24 hours after checkout)
[Learn more about automatic reminders →](/help/docs/for-merchants/automatic-id-check-reminders)
## Setup Complete!
You've configured Real ID for your WooCommerce store. Here's a summary:
- **Platform**: WooCommerce
- **Flow**: After Checkout
- **Triggers**: Configured based on your needs
- **Branding**: Customized with your logo and colors
- **Feedback**: Order metadata and status syncing
- **Order Holding**: Using order status mapping
### What's Next?
- [Send a test verification](/help/docs/getting-started/test-mode) to yourself
- [Review an ID check](/help/docs/for-merchants/viewing-id-checks) in the dashboard
- Explore [additional rules](/help/docs/rules/face-match) like biometric face matching
---
// File: getting-started/_steps/_store-gate-custom
# Set Up Store Gate
The "Before Viewing Store" flow requires all visitors to verify their identity before they can access your site or application. This is ideal for age-restricted content or exclusive membership sites.
## How It Works
1. When a visitor arrives, check if they have a valid verification
2. If not verified, show the verification flow (blocking access to content)
3. Once verified, store the verification status and allow access
4. Remember verified visitors so they don't need to verify again
## Implementation Approaches
### Option 1: JavaScript SDK (Client-Side)
Use the JavaScript SDK to gate access on the client side:
```html
```
### Option 2: Server-Side Verification
For stronger protection, verify on the server:
```javascript
// Middleware example (Express.js)
async function requireVerification(req, res, next) {
// Check session or cookie for verification status
const verificationId = req.cookies.realid_verification;
if (verificationId) {
// Verify the check is still valid
const check = await fetch(`https://api.getverdict.com/v1/checks/${verificationId}`, {
headers: { 'Authorization': `Bearer ${process.env.REALID_API_KEY}` }
}).then(r => r.json());
if (check.status === 'approved') {
return next(); // Allow access
}
}
// Redirect to verification page
res.redirect('/verify');
}
// Apply to protected routes
app.use('/shop', requireVerification);
app.use('/products', requireVerification);
```
### Verification Page
Create a dedicated verification page:
```javascript
// /verify route
app.get('/verify', (req, res) => {
res.render('verify', {
publicKey: process.env.REALID_PUBLIC_KEY,
returnUrl: req.query.return || '/'
});
});
// Handle verification completion via webhook
app.post('/webhooks/realid', (req, res) => {
const event = req.body;
if (event.type === 'check.approved') {
// Store verification in your database
// The visitor can now access protected content
}
res.sendStatus(200);
});
```
## Storing Verification Status
Options for remembering verified visitors:
### Cookies
```javascript
// Set a secure cookie after verification
res.cookie('realid_verified', checkId, {
httpOnly: true,
secure: true,
maxAge: 30 * 24 * 60 * 60 * 1000 // 30 days
});
```
### Database (for logged-in users)
```javascript
// Store on user record
await db.users.update({
where: { id: userId },
data: {
idVerified: true,
idVerifiedAt: new Date(),
realidCheckId: checkId
}
});
```
## Verification Rules
Since there's no order, verification is based on the visitor only:
- **Age verification** - Require minimum age
- **Face match** - Require selfie matching ID photo
- **Document types** - Specify accepted ID types
Configure these in your Real ID dashboard under **Settings** → **Rules**.
## Excluding Pages
Allow access to certain pages without verification:
```javascript
const publicPaths = ['/privacy', '/terms', '/contact', '/verify'];
function requireVerification(req, res, next) {
if (publicPaths.includes(req.path)) {
return next(); // Skip verification
}
// ... verification logic
}
```
## Testing
1. Clear your cookies or use incognito mode
2. Visit a protected page
3. Complete verification using [test mode](/help/docs/getting-started/test-mode)
4. Verify you can now access protected content
5. Refresh to confirm verification is remembered
[View full JS SDK documentation →](/help/docs/js)
---
// File: getting-started/_steps/_store-gate-shopify
# Set Up Store Gate
The "Before Viewing Store" flow requires all visitors to verify their identity before they can browse your products. This is ideal for age-restricted stores or exclusive membership sites.
## How It Works
1. When a visitor arrives at your store, they see a verification prompt instead of your products
2. The visitor completes ID verification
3. Once verified, they can browse and shop normally
4. Verified visitors are remembered and won't be prompted again
## Enable the Store Gate
1. Open the Real ID app in your Shopify admin
2. Go to **Settings** → **Automations**
3. Enable **Automated ID checks**
4. Select **Before viewing store** as the flow
## Add the Theme Block
For the store gate to work, you need to add the Real ID block to your theme:
1. Go to **Online Store** → **Themes** in Shopify admin
2. Click **Customize** on your active theme
3. In the theme editor, go to **App embeds** (or **Theme settings**)
4. Enable the **Real ID Store Gate** embed
5. Click **Save**
:::tip
The store gate uses a full-page overlay that covers your store content until the visitor is verified.
:::
## Customize the Gate
You can customize what visitors see on the verification gate:
1. Go to **Settings** → **Appearance** in Real ID
2. Edit the **Welcome message** to explain why verification is required
3. Upload your logo so visitors recognize your brand
4. Choose colors that match your store theme
## Verification Rules
Since there's no order at this point, verification is based on the customer only:
- **Age verification** - Check if the visitor meets your minimum age requirement
- **Face match** - Require a selfie to match the ID photo
- **Document types** - Choose which ID types to accept
:::note
Location-based age rules will use the address on the customer's ID document, since there's no shipping address available.
:::
## Remembering Verified Visitors
Once a visitor completes verification:
- A cookie remembers them on that device/browser
- If they create an account, verification is linked to their customer profile
- They won't need to verify again unless they clear cookies or use a new device
## Testing
To test the store gate:
1. Open your store in an incognito/private browser window
2. You should see the verification prompt
3. Complete verification using [test mode](/help/docs/getting-started/test-mode)
4. After verification, you should be able to browse the store
[Learn more about the Before Viewing Store flow →](/help/docs/flows/before-viewing-store)
---
// File: getting-started/_steps/_store-gate-woocommerce
# Set Up Store Gate
The "Before Viewing Store" flow requires all visitors to verify their identity before they can browse your products. This is ideal for age-restricted stores or exclusive membership sites.
## How It Works
1. When a visitor arrives at your store, they see a verification prompt instead of your products
2. The visitor completes ID verification
3. Once verified, they can browse and shop normally
4. Verified visitors are remembered and won't be prompted again
## Enable the Store Gate
1. Go to **Real ID** → **Settings** in your WordPress admin
2. Navigate to the **Automations** tab
3. Enable **Automated ID checks**
4. Select **Before viewing store** as the flow
5. Click **Save**
## How the Gate Displays
Real ID automatically adds a full-page overlay to your site that:
- Covers all store content until verification is complete
- Shows your logo and custom welcome message
- Provides the verification flow inline
The gate is injected via JavaScript, so no theme modifications are required.
## Customize the Gate
You can customize what visitors see on the verification gate:
1. Go to **Real ID** → **Settings** → **Appearance**
2. Edit the **Welcome message** to explain why verification is required
3. Upload your logo so visitors recognize your brand
4. Choose colors that match your store theme
## Exclude Specific Pages
You may want to allow access to certain pages without verification (like your privacy policy or contact page):
1. Go to **Real ID** → **Settings** → **Automations**
2. Find the **Excluded pages** setting
3. Add the page slugs or IDs you want to exclude
Common pages to exclude:
- `/privacy-policy/`
- `/terms-of-service/`
- `/contact/`
## Verification Rules
Since there's no order at this point, verification is based on the customer only:
- **Age verification** - Check if the visitor meets your minimum age requirement
- **Face match** - Require a selfie to match the ID photo
- **Document types** - Choose which ID types to accept
:::note
Location-based age rules will use the address on the customer's ID document, since there's no shipping address available.
:::
## Remembering Verified Visitors
Once a visitor completes verification:
- A cookie remembers them on that device/browser
- If they're logged in, verification is linked to their WordPress user account
- They won't need to verify again unless they clear cookies or use a new device
## Testing
To test the store gate:
1. Log out of WordPress (or use incognito mode)
2. Visit your store's homepage
3. You should see the verification prompt
4. Complete verification using [test mode](/help/docs/getting-started/test-mode)
5. After verification, you should be able to browse the store
[Learn more about the Before Viewing Store flow →](/help/docs/flows/before-viewing-store)
---
// File: getting-started/_steps/_triggers-bigcommerce
# Configure Verification Triggers
Triggers determine which orders require ID verification. You can enable multiple triggers - if any trigger matches, the customer will be prompted to verify their ID.
## Access Trigger Settings
1. Log in to your Real ID dashboard
2. Navigate to **Settings** → **Automations**
3. Ensure **Enable automated ID checks** is turned on
## Available Triggers
### All Orders
Enable this to verify every customer who places an order. Best for:
- Age-restricted product stores
- High-security requirements
- Compliance mandates
### High Value Orders
Verify orders above a specified total amount. Great for:
- Reducing fraud on expensive items
- Protecting against chargebacks
Set your threshold (e.g., orders over $200) in the settings.
### Specific Products
Verify only when certain products are in the cart:
1. Go to the **Filters** section in settings
2. Select the products that require verification
3. Orders containing those products will trigger verification
### Shipping Location
Verify orders shipping to specific regions:
- All U.S. orders
- Specific U.S. states
- Useful for location-based age requirements
## Order Status Syncing
BigCommerce orders can be automatically updated based on verification status:
1. Go to **Settings** → **Order Statuses**
2. Configure which BigCommerce status to use for:
- Orders pending verification
- Orders that passed verification
- Orders that failed verification
[Learn more about order status syncing →](/help/docs/bigcommerce/order-statuses)
## Exceptions
You can exclude orders from verification based on:
- **Already verified customers** - Don't re-verify repeat customers
- **Specific shipping methods** - Exclude certain delivery types
## Custom Trigger Scripts
For advanced trigger logic, BigCommerce supports custom scripts. See our [BigCommerce custom trigger documentation](/help/docs/bigcommerce/after-checkout#custom-trigger-scripts) for examples.
## Next Steps
After setting up triggers, we'll customize how the verification appears to your customers.
---
// File: getting-started/_steps/_triggers-custom
# Triggering ID Verification
With the API integration, you have full control over when to trigger ID verification. Here are common patterns and best practices.
## Creating an ID Check
Use the REST API to create an ID check when you want to verify a customer:
```javascript
// Server-side example (Node.js)
const response = await fetch('https://api.getverdict.com/v1/checks', {
method: 'POST',
headers: {
'Authorization': `Bearer ${process.env.REALID_API_KEY}`,
'Content-Type': 'application/json'
},
body: JSON.stringify({
email: customer.email,
phone: customer.phone, // Optional - enables SMS delivery
name: customer.name,
orderId: order.id, // Your internal order ID
orderNumber: order.number, // Human-readable order number
sendEmail: true, // Send verification email automatically
sendSms: customer.phone ? true : false
})
});
const check = await response.json();
console.log('Created ID check:', check.id);
```
## Common Trigger Patterns
### Order-Based Triggers
```javascript
// Trigger based on order value
if (order.total > 200) {
await createIdCheck(customer, order);
}
// Trigger based on products
const requiresId = order.items.some(item =>
item.categories.includes('age-restricted')
);
if (requiresId) {
await createIdCheck(customer, order);
}
// Trigger based on customer history
if (customer.orderCount === 1) { // First-time customer
await createIdCheck(customer, order);
}
```
### Risk-Based Triggers
```javascript
// Trigger based on fraud score (from your fraud detection system)
if (order.fraudScore > 0.7) {
await createIdCheck(customer, order);
}
// Trigger based on address mismatch
if (order.billingAddress.country !== order.shippingAddress.country) {
await createIdCheck(customer, order);
}
```
### Location-Based Triggers
```javascript
// Trigger based on shipping state (for age verification)
const ageRestrictedStates = ['CA', 'NY', 'TX'];
if (ageRestrictedStates.includes(order.shippingAddress.state)) {
await createIdCheck(customer, order);
}
```
## JavaScript SDK Integration
For client-side triggering, use the JavaScript SDK:
```javascript
// Initialize with your public key
RealID.init({ publicKey: 'pk_live_xxx' });
// Trigger verification based on cart contents
if (cartContainsAgeRestrictedItem()) {
RealID.verify({
email: customerEmail,
onComplete: (result) => {
if (result.status === 'approved') {
// Allow checkout to proceed
enableCheckoutButton();
} else {
// Handle failed verification
showVerificationRequired();
}
}
});
}
```
## Handling Verification Results
### Webhooks (Recommended)
Set up webhooks to receive real-time notifications:
```javascript
// Webhook handler example
app.post('/webhooks/realid', (req, res) => {
const event = req.body;
switch (event.type) {
case 'check.approved':
// Update order status, fulfill order, etc.
fulfillOrder(event.data.orderId);
break;
case 'check.failed':
// Hold order, notify staff, etc.
holdOrder(event.data.orderId);
notifyStaff(event.data);
break;
case 'check.pending':
// Customer started but hasn't completed
break;
}
res.sendStatus(200);
});
```
### Polling
If webhooks aren't available, poll the check status:
```javascript
async function waitForVerification(checkId, maxAttempts = 30) {
for (let i = 0; i < maxAttempts; i++) {
const check = await getCheck(checkId);
if (check.status !== 'pending') {
return check;
}
await sleep(10000); // Wait 10 seconds
}
throw new Error('Verification timeout');
}
```
## Next Steps
After implementing triggers, we'll customize how the verification appears to your customers.
---
// File: getting-started/_steps/_triggers-shopify-after-checkout
# Configure After Checkout Verification
You've selected the **After Checkout** flow. Let's configure when and how ID verification appears to your customers.
## Step 1: Enable After Checkout Flow
1. Open the Real ID app in your Shopify admin
2. Navigate to **Settings** → **Automations**
3. Enable **Automated ID checks**
4. Select **After Checkout** as your verification flow
5. Click **Save**

## Step 2: Add Checkout Extensions (Recommended)
For the best customer experience, add the Real ID checkout extensions to display verification directly on the Thank You and Order Status pages:
1. In Shopify admin, go to **Settings** → **Checkout**
2. Click **Customize** next to your checkout
3. Navigate to the **Thank you** page
4. Click **Add app block** and select **Real ID**
5. Repeat for the **Order status** page
6. Click **Save**
:::tip
Without checkout extensions, Real ID will still work by sending verification links via email and SMS. The extensions provide an inline experience that increases completion rates.
:::
[Learn more about Checkout Extensions →](/help/docs/flows/during-checkout)
## Step 3: Configure Triggers
Triggers determine which orders require ID verification. You can enable multiple triggers - if any trigger matches, the customer will be prompted to verify their ID.
## Available Triggers
### All Orders
Enable this to verify every customer who places an order. Best for:
- Age-restricted product stores
- High-security requirements
- Compliance mandates
### High Value Orders
Verify orders above a specified total amount. Great for:
- Reducing fraud on expensive items
- Protecting against chargebacks
Set your threshold (e.g., orders over $200) in the settings.
### High Risk Orders
Automatically verify orders flagged as medium or high risk by Shopify's fraud analysis. This works with:
- Shopify's built-in fraud detection
- Third-party fraud prevention apps
### Specific Products or Collections
Verify only when certain products are in the cart:
1. Create a collection for products requiring verification
2. In Real ID settings, select that collection
3. Orders containing those products will trigger verification
:::tip
Create a hidden collection called "ID Required" to easily manage which products need verification.
:::
### Mismatching Billing/Shipping
Verify when the billing name or address doesn't match the shipping address. Helps catch potential fraud.
### Shipping Location
Verify orders shipping to specific regions:
- All U.S. orders
- Specific U.S. states
- Useful for location-based age requirements
## Exceptions
You can exclude orders from verification based on:
- **Already verified customers** - Don't re-verify repeat customers
- **In-store pickup** - Skip verification for pickup orders
- **Specific shipping methods** - Exclude certain delivery types
- **Payment gateways** - Skip orders paid via PayPal, etc.
- **Sales channels** - Exclude marketplace orders (Amazon, Walmart)
## Advanced: Shopify Flow
For complex trigger logic, use [Shopify Flow integration](/help/docs/shopify/flow) to create custom conditions.
## Next Steps
After setting up triggers, we'll customize how the verification appears to your customers.
---
// File: getting-started/_steps/_triggers-shopify-after-registration
# Configure After Registration Verification
You've selected the **After Registration** flow. This flow verifies customers when they create an account on your store, rather than during the checkout process.
## Step 1: Enable After Registration Flow
1. Open the Real ID app in your Shopify admin
2. Navigate to **Settings** → **Automations**
3. Enable **Automated ID checks**
4. Select **After Registration** as your verification flow
5. Click **Save**
## Step 2: How It Works
When a customer creates an account on your store:
1. They complete Shopify's standard account registration
2. Real ID sends them a verification request via email
3. The customer completes ID verification
4. Their account is marked as verified with a customer tag
## Step 3: Configure Customer Tags
Real ID uses Shopify customer tags to track verification status:
1. In Real ID settings, go to **Tags & Feedback**
2. Configure the tags for:
- **Verified customers** - Tag applied when verification passes
- **Pending verification** - Tag applied when awaiting verification
- **Failed verification** - Tag applied when verification fails
You can use these tags in Shopify to:
- Grant access to exclusive content or products
- Apply special pricing or discounts
- Filter customers in your admin
[Learn more about customer tags →](/help/docs/shopify/tags)
## Available Triggers
For After Registration, triggers work differently than order-based flows:
### All Registrations
Verify every new customer account created on your store. Best for:
- Age-gated stores requiring verified customers
- Membership sites
- B2B stores requiring identity verification
### Specific Customer Groups
You can configure verification based on:
- Customer location (shipping address country/state)
- Email domain filtering
- Custom conditions via Shopify Flow
## Exceptions
You can exclude accounts from verification based on:
- **Previously verified** - Skip customers already verified from orders
- **Specific email domains** - Allow certain domains without verification
## Integration with Checkout
If you also want to verify at checkout:
- After Registration ensures all account holders are verified
- You can combine with After Checkout for guest purchases
- Verified customers skip checkout verification automatically
[Learn more about the After Registration flow →](/help/docs/flows/after-registration)
## Next Steps
After setting up triggers, we'll customize how the verification appears to your customers.
---
// File: getting-started/_steps/_triggers-shopify-before-checkout
# Configure Before Checkout Verification
You've selected the **Before Checkout** flow. Let's configure when and how ID verification appears to your customers.
## Step 1: Enable Before Checkout Flow
1. Open the Real ID app in your Shopify admin
2. Navigate to **Settings** → **Automations**
3. Enable **Automated ID checks**
4. Select **Before Checkout** as your verification flow
5. Click **Save**
## Step 2: Add Checkout Extensions (Required)
Before Checkout verification uses Shopify's checkout extensions to display the verification form during checkout. This is required for the Before Checkout flow to work:
1. In Shopify admin, go to **Settings** → **Checkout**
2. Click **Customize** next to your checkout
3. In the checkout editor, click **Add app block**
4. Select **Real ID** from the list
5. Position the block where you want verification to appear (typically in the contact or shipping section)
6. Click **Save**
:::warning
The Before Checkout flow requires checkout extensions to be enabled. Without this, customers won't see the verification form during checkout.
:::
[Learn more about Checkout Extensions →](/help/docs/flows/during-checkout)
## Step 3: Configure Triggers
Triggers determine which checkouts require ID verification. You can enable multiple triggers - if any trigger matches, the customer will be prompted to verify their ID before completing checkout.
## Available Triggers
### All Orders
Enable this to verify every customer at checkout. Best for:
- Age-restricted product stores
- High-security requirements
- Compliance mandates
### High Value Orders
Verify checkouts above a specified total amount. Great for:
- Reducing fraud on expensive items
- Protecting against chargebacks
Set your threshold (e.g., orders over $200) in the settings.
### Specific Products or Collections
Verify only when certain products are in the cart:
1. Create a collection for products requiring verification
2. In Real ID settings, select that collection
3. Checkouts containing those products will trigger verification
:::tip
Create a hidden collection called "ID Required" to easily manage which products need verification.
:::
### Shipping Location
Verify checkouts shipping to specific regions:
- All U.S. orders
- Specific U.S. states
- Useful for location-based age requirements
## Exceptions
You can exclude checkouts from verification based on:
- **Already verified customers** - Don't re-verify repeat customers
- **In-store pickup** - Skip verification for pickup orders
- **Specific shipping methods** - Exclude certain delivery types
## Checkout Experience
With Before Checkout verification:
- Customers verify their ID during the checkout process
- Verification is completed before payment is processed
- Orders are only created for verified customers
- No need to hold or cancel orders post-purchase
[Learn more about the Before Checkout flow →](/help/docs/flows/before-checkout)
## Next Steps
After setting up triggers, we'll customize how the verification appears to your customers.
---
// File: getting-started/_steps/_triggers-woocommerce
# Configure Verification Triggers
Triggers determine which orders require ID verification. You can enable multiple triggers - if any trigger matches, the customer will be prompted to verify their ID.
## Access Trigger Settings
1. In your WordPress admin, go to **Real ID** → **Settings**
2. Navigate to the **Automations** tab
3. Ensure **Enable automated ID checks** is turned on
## Available Triggers
### All Orders
Enable this to verify every customer who places an order. Best for:
- Age-restricted product stores
- High-security requirements
- Compliance mandates
### High Value Orders
Verify orders above a specified total amount. Great for:
- Reducing fraud on expensive items
- Protecting against chargebacks
Set your threshold (e.g., orders over $200) in the settings.
### Specific Product Categories
Verify only when products from certain categories are in the cart:
1. Go to the **Filters** section in Automations settings
2. Enable the **Categories** filter
3. Select the categories that require verification
:::tip
Create a category called "Age Restricted" or "ID Required" to easily manage which products need verification.
:::
### Specific Products
You can also select individual products that require verification, independent of their category.
### Mismatching Billing/Shipping
Verify when the billing name or address doesn't match the shipping address. Helps catch potential fraud.
### Shipping Location
Verify orders shipping to specific regions:
- All U.S. orders
- Specific U.S. states
- Useful for location-based age requirements
## Order Status Integration
WooCommerce orders can be automatically held or updated based on verification status:
1. Go to **Real ID** → **Settings** → **Order Statuses**
2. Configure which WooCommerce status to use for:
- Orders pending verification
- Orders that passed verification
- Orders that failed verification
[Learn more about order status syncing →](/help/docs/woocommerce/order-statuses)
## Exceptions
You can exclude orders from verification based on:
- **Already verified customers** - Don't re-verify repeat customers
- **Specific shipping methods** - Exclude certain delivery types
- **Payment gateways** - Skip orders paid via PayPal, etc.
## Next Steps
After setting up triggers, we'll customize how the verification appears to your customers.
---
// File: getting-started/test-mode
# Test Mode
When you first install Real ID to your store, the app is in **Test Mode**.
In test mode, you're granted all features for free and can also send test ID checks at no charge.
This gives you the opportunity to sample all of Real ID's features and verify it works correct with your store and theme before choosing a plan.
If the app is in test mode, you'll see this banner at the top of each page:

:::tip
Real ID is free to install on any Shopify store, including [Development Stores](https://help.shopify.com/en/partners/dashboard/managing-stores/development-stores).
Test mode will still activate triggers like [ID verification on specific types or orders](./../flows/after-checkout.mdx), or flows like [ID verification before checkout](./../flows/before-checkout.mdx).
We recommend you install Real ID on a development store first in order to trial these features before applying it to your live store.
:::
## Restrictions
In test mode, you'll be able to use all **Pro** level features as well as send ID checks.
However, there are a few restrictions:
* All ID checks sent in test mode will have mock fake data and will always pass
* Enterprise features are not included in test mode
:::info
ID checks sent during test mode will have mock data that represents what the app could read.
The images of the ID and headshot will also be blurred.
:::
## Notifications in Test Mode
In test mode, **no emails or SMS messages are sent to your customers**. Instead, notification emails are redirected to your store's [contact email](/help/docs/for-merchants/id-check-notifications) with a **[TEST]** prefix in the subject line.
This means you can:
* Safely create test ID checks using real customer order data without worrying about customers receiving unexpected messages
* Preview exactly what the customer email looks like in your own inbox
* Easily identify test emails by the **[TEST]** tag in the subject line
:::note
SMS notifications are skipped entirely in test mode since they cannot be redirected. Only email notifications are sent (to the merchant contact email).
Automatic reminders are also not scheduled for test mode checks.
:::
## Going live
After you've had a chance to try out the features and decide which plan fits best for your needs, click the **Go Live** button on the left hand side menu:

After picking a plan, you'll be able to send real ID checks with actual results and unblurred photos.
:::note
You're only able to go into test mode once. But you can downgrade or upgrade your plan at any time.
:::
---
// File: id-check-process
# ID check process
Real ID uses the latest computer vision and A.I. technologies to quickly verify and extract details from ID documents like Driver's Licenses, Passports and Residence Cards.
It can be set up to verify IDs before checkout, after checkout or even before being allowed to view your store. Additionally, you can have it set up to only trigger ID verification on specific high risk triggers like total order value or Shopify Fraud Analysis flags.
You also can require additional documentation like a corresponding live headshot photo, Proof of Address, and eSignature.
The entire process can be completed in as little as a few minutes, and it's entirely automated. But staff can override the automatic results at any time.
## How it works
The way a customer is presented with their ID check depends on which flow you choose. But the process is roughly the same for each.
First, the customer opens their unique ID check associated with their account. Then they're guided through capturing the photos required according to your rules.
Computer vision techniques during the process help guide the customer to take the best photo possible for the best results. Then, the customer will be either automatically approved, or placed into review.
:::tip
These are not the exhaustive list of methods Real ID uses to verify identity, but a general overview of the various technologies and techniques in place.
:::
## Autocapturing ID photos and headshots
Real ID uses A.I. during the capturing of ID photos and headshots to help guide the user to take the best possible photo to optimize for their chance of passing ID verification.
This A.I. running on the customer's phone during the ID verification process helps guide them to place their ID within the camera frame at the correct position.
It will help guide customers by giving them feedback to show the ID, move it closer or further way from the camera for focus.
This helps vastly improve photo quality and helps guide customers to take the best possible photo of their ID
A similar A.I. model is used to help guide customers to take a headshot, if required by your rules.
:::note
The ID autocapture will allow customers to manually capture a photo of their ID after a certain period of time.
This is to help customers in extraordinary circumstances still submit photos of their IDs. Then you'll be able to take the final judgement and approve or reject these submissions manually.
The Real ID dashboard will show you if a submission was manually captured instead of automatically captured.
:::
## How is an ID accepted or rejected?
During verification, an ID is accepted when all required fields such as name, address, date of birth, and date of expiration can be read with high confidence and meet your additional rules such as [cross checking order details](./rules/cross-checking-orders.md), [biometric verification](#face-match), and [age verification](./rules/age-verification.md).
Real ID uses multiple A.I. models to determine the validity and liveness of the photos as
well as models to extract the fields from the ID into a standard format.
But this confidence is customizable, you can lower or raise the threshold of confidence required for an accepted ID.
Additionally, you can manually override the results at any time, even if the system is unable to automatically verify it.
:::note Hard rules
Some rules don't rely on confidence alone, such as detecting expired ID documents. Adjusting the confidence threshold for your ID checks won't affect the expiration date checks for example.
:::
## Maximum soft retries
During the ID check process, customers are given 3 attempts per stage to take a high quality, readable and usable photo.
For example, if the ID check requires both the ID photo and a portrait photo to face match against, then customers are given 3 tries to take a good quality photo of their ID as well as 3 photos of their face.
These "soft" retries do not incur extra charges. Customers can use all 3 attempts per stage, and you'll only be charged once for the entire check.
If customers fail all soft retries in a particular stage, then they'll allowed to move onto the next stage.
This allows customers to still continue through the flow in case they have a document that isn't supported like a temporary issued Drivers License, or damaged ID, and gives you a chance to [override the failed ID checks](./for-merchants/overridding-results.md).
If you still want to allow customers to try again with a "hard" retry, where customers can try again with a new fresh ID check, [please see this article](./for-merchants/retrying-id-checks.md).
## Allowed captured methods
By default Real ID allows customers to both capture photos using their device's camera only.
This is the most secure option, since it requires customers to take a live photo of their ID document, as well as take a live selfie photo.
[However you can enable manual photo uploading](./rules/control-capture-methods.md). This allows customers to upload photos from their camera roll if they don't have their ID phyiscally available because it's lost or stolen.
However, manual file uploads bypass the ID and headshot photo Autocapture feature, which may lead to bad quality photos or a higher chance of failing the ID check.
Additionally, disabling the manual file uploads helps increase security because it helps narrow down the possibility of a bad actor using a stolen images.
:::tip
The Real ID dashboard will show if photos from the ID check were uploaded via a file or captured from the user's camera.
In general, photos captured in real time from the camera are more trustworthy than file uploads.
:::
## Face Match
If you enable the headshot requirement, Real ID will also verify the headshot matches the headshot physically printed on the ID document.
You'll be able to see the similiarity confidence of the captured headshot against the headshot on the ID document from 0% to 100% within the ID check details in the dashboard.
If the ID check passes, yet the headshot cannot be confidently matched, then the entire ID check is rejected.
:::tip
Even if a ID check is rejected to a mismatching photo, you'll be able to override the results in the dashboard.
:::
## Text Extraction
Real ID uses modern computer vision techniques to read text fields on the verified ID photo.
Real ID can read text fields from Driver's Licenses, Passports, etc like:
- `First Name`
- `Middle Name`
- `Last Name`
- `Document Number`
- `Address`
- `Date of Birth`
- `Date of Expiration`
- `Endorsements`
- `Classes`
These fields are especially useful for applying a minimum age verification to your products, or rejecting expired ID documents, or verifying that the shipping or payment details match up with the customer's ID.
:::note
Some fields like the `First Name` and `Last Name` fields are required in order for the ID check to pass automatically.
If an ID check fails because one or more required fields are covered, missing or are inlegible, then you'll see that reason within the ID check details in the dashboard.
:::
## Completed
When the customer submits their required information, their photos will undergo additional processing with A.I. models running in Real ID's private cloud.
Then Real ID will use the combination verdicts from these models and the results of the [enabled additional rules](./rules/cross-checking-orders.md) to determine if the ID check passes or fails.
If the customer fails, they're shown feedback that their ID wasn't able to be automatically passed.
If the customer passes, they're shown a call to action to return to the order status page, or return to the cart to checkout, or to notify them they can browse and checkout within your store. Each depends on which ID verification flow you've choosen.
:::tip
By default Real ID does _not_ cancel or modify the order in any way, even if the ID check failed.
Real ID will update metadata, tags and metafields on the orders with ID checks - regardless if the ID check passed or failed.
:::
## What happens after automatic verification
Once a customer submits their photos, every ID check ends up in one of a few outcomes. The diagram below shows how a check moves from submission to a final result, and where your staff can step in.
```mermaid
flowchart TD
A[Customer submits photos] --> B{Automatic verification}
B -->|Passes rules & confidence| C([Verified])
B -->|Low confidence, missing fields, expired ID or other failure| D([In Review])
C -.->|Verified email sent| C1[Customer told they're approved]
D -.->|In Review email sent unless disabled| D1[Customer told it's under review]
D --> E{Staff review in dashboard}
E -->|Approve Check| F([Manually Approved])
E -->|Reject Check| G([Manually Rejected])
F -.->|Verified email sent| F1[Customer told they're approved]
G -.->|Failed email sent| G1[Customer told it failed]
style C fill:#dcfce7,stroke:#16a34a,color:#14532d
style F fill:#dcfce7,stroke:#16a34a,color:#14532d
style D fill:#fef9c3,stroke:#ca8a04,color:#713f12
style G fill:#fee2e2,stroke:#dc2626,color:#7f1d1d
```
An **In Review** check is never a dead end — it simply waits for your team to make the final call. You can [override the results at any time](./for-merchants/overridding-results.md).
### Verified (automatic)
The ID passed all of your required fields, [additional rules](./rules/cross-checking-orders.md) and the confidence threshold automatically, with no staff action needed.
* **Merchant options:** none required. You can still manually reject it later if something looks wrong.
* **Customer notification:** the `Verified` email is sent automatically. The customer is shown a call to action to continue (return to the order status page, back to the cart, or continue browsing) depending on your [flow](./flows/before-checkout.mdx).
### In Review
The ID could not be automatically verified — because of low image quality, missing or unreadable fields, an expired document, a [face match](#face-match) mismatch, a failed [cross-check](./rules/cross-checking-orders.md), or any other rule. The check is held for your team and appears under the **In Review** filter in the dashboard. Orders are **not** cancelled or modified — you decide what happens next.
* **Merchant options:** open the check in the Real ID dashboard and either [**Approve Check** or **Reject Check**](./for-merchants/overridding-results.md). If you'd like to give the customer a fresh attempt instead, you can send a [hard retry](./for-merchants/retrying-id-checks.md).
* **Customer notification:** the `In Review` email is sent, telling the customer their verification needs review and that you'll follow up. This email [can be disabled](./theming/customize-content.md#disabling-customer-emails) — if it is, the customer receives nothing at this stage. Your team is also notified so you can review before fulfilling.
### Manually approved
A staff member reviewed an in-review check and clicked **Approve Check**. The check is now treated as passed everywhere in Real ID — including tags, metafields and notes, and any [before-checkout](./flows/before-checkout.mdx) or [before-viewing-store](./flows/before-viewing-store.md) gates.
* **Merchant options:** you can still reject the check later if needed.
* **Customer notification:** the same `Verified` email is sent, so from the customer's perspective a manual approval looks identical to an automatic pass.
### Manually rejected
A staff member opened the **More actions** menu and selected **Reject Check**. The check is now treated as failed everywhere in Real ID.
* **Merchant options:** you can re-approve the check at any time, or send the customer a [hard retry](./for-merchants/retrying-id-checks.md) to try again with a new ID check.
* **Customer notification:** the `Failed` email is sent. This email is **only** ever sent on a manual rejection — an automatic failure alone (In Review) never triggers it.
---
// File: integrations/brightpearl
# BrightPearl Integration
Real ID can automatically sync ID checks on your orders with BrightPearl and update their corresponding **order status** when customer's complete ID checks.
That way you can automate a holding process, where a high risk order is automatically held until the customer completes ID verification successfully.
## How does it work?
Real ID integrates with Brightpearl as a custom private app. Once you enter in the Brightpearl privateapp credentials in Real ID, then pick **order statuses** that should be applied to when the customer completes or requires ID verification from your ID triggers.
## Creating a BrightPearl App
First, create a Brightpearl staff app in your BrightPearl dashboard.
* Log into your Brightpearl account
* Go to **App Store > Private apps**
* Click **“Add private app”**
* Select **“staff app” **to ensure you are capturing detailed information about who performs any actions on your account. **“System”** apps are being sunsetted and should not be used anymore.
* Enter **"[account_ID]_real-id"** as the name. The `[account_ID]` portion should be your unique account name in Brightpearl.
* Save
After saving, you'll be shown the password to authenticate with this app. Copy down both the private app name and this password for the next step.
## Integrating the Brightpearl App with Real ID
Now that you have a custom Brightpearl app, let's connect it to Real ID.
Open the Real ID **Settings > DevTools** and scroll to the **Brightpearl Integration **setttings.
Then enter in the **"[account_ID]_real-id"** app name you defined in the Brightpearl custom app, and then paste in the staff password that should have been created when you as well.
As you enter in your credentials, Real ID will test the connection. If the credentials are correct, you'll see a **"Connected"** message in the bottom of the form.

## Choosing Brightpearl Order Statuses
After setting up the integration and successfully connecting, you can now choose which order statuses should be applied during ID check events.
Once connected, open the dropdowns for the order statuses that should apply to each ID check event.
Then when you've made your selection, enable the integration by clicking the toggle at the top of the form and saving your settings.

## Frequently Asked Questions
### The Brightpearl order status we were using was deleted, how do I fix the integration?
Real ID uses references to the Brightpearl order status options in your account. The dropdowns in the Real ID settings for Brightpearl will refresh in real time, so simply select a different status to fix the integration.
### I've connected the app, and selected order statuses but they aren't updated.
Make sure that there isn't an order prefix added to your orders in Brightpearl. They are usually a 2 letter code. Make sure you enter in this prefix into the settings in Real ID so that it can find your orders in Brightpearl.
---
// File: integrations/customer-fields
# Helium Customer Fields
Real ID integrates into [Helium's Customer Fields](https://apps.shopify.com/customr?utm_source=real_id&utm_campaign=docs) so you can add modern ID verification to your wholesale or customer registration forms.
:::info
This guide assumes you have Customer Fields and Real ID installed on your Shopify store.
- [Install Helium Customer Fields](https://apps.shopify.com/customr)
- [Install Real ID](https://apps.shopify.com/real-id)
:::
## Getting Started
First, open the Customer Fields app and open the form that you'd like to add ID verification to.
Then in the Form Editor add a custom HTML block:

After dragging and dropping the custom HTML block into your form, click on the new field, you should see a the HTML block's editor appear on the left hand side:

Copy the code below and paste it into this **Content** field for your HTML custom block:
```html
ID verification
We require all customers to verify their ID as a part of account
registration.
This one time ID verification is instant and secure through our partner Real
ID.
The button below is for demonstration only. Design and content will change
in your live form.
Start
```
You should now see a place holder for the ID verification prompt appear in your form. Your [same theme, content and branding](../theming/branding.md) appear in the live version of your form.
:::info
The **Start** button in this ID verification placeholder isn't functional within the Customer Fields Form Editor.
However, on the live version of your form it will function properly.
:::
Finally, don't forget to click **Save** in the top right corner of the Form Editor to make sure these changes have been saved.
## Frequently Asked Questions
### Is the Customer Fields integration available on all Real ID plans?
Yes, this integration is available on all Real ID plans.
### I have an approval step before Customer Fields creates the customer record, will this still work?
Yes, Real ID can still verify your customer's ID, then you can view the ID verification results in the Real ID app before you approve their account.
### I'm having issues setting this up, can you help me?
Of course, happy to help. [Please contact us](https://getverdict.com/contact) so we can help you get ID verification embedded into your Customer Fields Form.
---
// File: integrations/semble
# Semble Integration
Real ID can automatically sync ID verification status to patient records in Semble, a Patient CRM system used by healthcare providers.
This integration allows healthcare providers to see verification status directly on patient records as labels, making it easy to track which patients have completed identity verification.
## How does it work?
Real ID integrates with Semble using their GraphQL API. When a customer completes (or starts) an ID check, Real ID automatically:
1. Searches for the patient in Semble using their email address
2. Removes any existing ID check label from the patient
3. Adds the appropriate label based on the current verification status
This happens in real-time as the verification status changes, keeping your patient records always up to date.
## Patient Labels
The following verification statuses are synced as patient labels in Semble:
| Label | Description |
|-------|-------------|
| **ID check in progress** | Customer has started but not completed verification |
| **ID check in review** | Verification is being manually reviewed |
| **ID check approved** | Customer successfully verified their identity |
| **ID check failed** | Verification was unsuccessful |
| **ID check manually approved** | Merchant manually approved the verification |
| **ID check manually rejected** | Merchant manually rejected the verification |
Labels are created automatically in Semble when needed. You don't need to create them manually.
## Setting Up the Integration
### Step 1: Get Your Semble API Key
First, you'll need to generate an API key in your Semble account:
1. Log into your Semble account
2. Navigate to **Settings > API Access**
3. Generate a new API key
4. Copy the API key for the next step
### Step 2: Connect Real ID to Semble
Open the Real ID **Settings > WooCommerce** tab and scroll to the **Semble Patient Label Syncing** settings.
1. Toggle **Enable Semble Integration** to on
2. Enter your **API Key** from Semble
3. Click **Test Connection** to verify the credentials work
4. Click **Save** in the top right corner
Once connected, Real ID will automatically sync verification statuses to patient records.
## Patient Matching
Real ID matches patients in Semble using the **email address** from the ID check. For syncing to work:
- The patient must already exist in Semble
- The patient's email in Semble must match the email used for the ID check
- Email matching is case-insensitive
If a patient isn't found in Semble, the sync is skipped and you'll see this noted in the ID check events.
## Synced Patient Data
In addition to labels, Real ID can also sync verified data from the ID document to the patient record:
- **Date of Birth**: When verification completes successfully, the date of birth extracted from the ID document is synced to the patient record in Semble
This helps ensure patient records have accurate, verified information.
## Viewing Sync Events
Each Semble sync action is logged as an event on the ID check. To view these events:
1. Open the ID check details in your WooCommerce admin
2. Scroll to the Events section
3. Look for events related to Semble syncing
Events will show whether the sync succeeded, was skipped (patient not found), or encountered an error.
## Frequently Asked Questions
### Why isn't the patient label updating?
Check the following:
1. **Integration enabled**: Verify the Semble integration is enabled in settings
2. **API key valid**: Use the "Test Connection" button to verify your credentials
3. **Patient exists**: The patient must already exist in Semble with a matching email
4. **Email matches**: The email on the ID check must match the patient's email in Semble
### What happens if the patient doesn't exist in Semble yet?
If Real ID can't find a patient with a matching email in Semble, the sync is skipped. The system includes automatic retry logic to handle cases where patients are being imported to Semble with a slight delay.
### Can I sync historical ID checks?
Yes, contact support to request a bulk sync of historical ID checks to Semble. This is useful when first setting up the integration.
### How quickly do labels update?
Labels are updated in real-time as verification status changes. You should see the label appear on the patient record within seconds of the status change.
### Can I customize the label names?
The label names are standardized to ensure consistency. All labels are prefixed with "ID check" followed by the status, making them easy to identify and filter in Semble.
### What if a patient has multiple ID checks?
Each time an ID check status changes, the previous ID check label is removed and replaced with the new one. A patient will only ever have one ID check label at a time, reflecting their most recent verification status.
---
// File: integrations/shipstation
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# ShipStation Integration
Real ID can automatically sync ID checks on your orders with ShipStation and update their corresponding **order status** when customers complete ID checks.
That way you can automate a holding process, where a high risk order is automatically held until the customer verifies their ID.
## How does it work?
Real ID integrates with ShipStation using their REST API. Once you enter your ShipStation API credentials in Real ID, then pick **order statuses** that should be applied when the customer completes or requires ID verification from your ID triggers.
Orders are searched in ShipStation using the Shopify order name (e.g. `#1001`) as the external reference, with optional prefix support for merchants who use prefixes in their ShipStation setup.
Orders are searched in ShipStation using the WooCommerce order ID as the external reference, with optional prefix support for merchants who use prefixes in their ShipStation setup.
## Creating ShipStation API Credentials
First, generate API credentials in your ShipStation account:
- Log into your [ShipStation API account](https://shipstation.auth0.com/login)

- Go to **Settings > API Settings**

- Click **"Generate API Keys"**, make sure to select the `v1 ShipStation API` key option

- Copy both the **API Key** and **API Secret** for the next step

## Integrating ShipStation with Real ID
Now that you have ShipStation API credentials, let's connect them to Real ID.
Open the Real ID app in your Shopify admin and navigate to **Settings > Developer Tools**. Scroll to the **ShipStation** section.
Enter your **API Key** and **API Secret** that you generated in ShipStation.
If your Shopify orders appear in ShipStation with a prefix (e.g. `SHOP-#1001` instead of just `#1001`), enter that prefix in the **Order Prefix** field. Otherwise, leave it blank.
Click **Test Connection** to verify the connection. If the credentials are correct, you'll see a success message.
Don't forget to click **Save** so these changes are saved.

Open the Real ID **Settings > WooCommerce** tab and scroll to the **ShipStation Integration** settings.
Then enter your **API Key** and **API Secret** that you generated in ShipStation:

If your WooCommerce orders appear in ShipStation with a prefix (like "WC-1234" instead of just "1234"), enter that prefix in the **Order Prefix** field. Otherwise, leave it blank.
As you enter your credentials, click **Test Connection** to verify the connection. If the credentials are correct, you'll see a **"Connected"** message.
Don't forget to click **Save** in the top right hand corner so these changes are saved.
## ShipStation Order Statuses syncing
After setting up the integration and successfully connecting, Real ID will automatically handle fulfillment statuses in ShipStation:
- **When ID Check is Created**: On Hold (prevents shipping until verified)
- **When ID Check Passes**: Awaiting Shipment (ready to fulfill)
- **When ID Check Fails**: Cancelled (prevents fulfillment)
## Order Processing Flow
### When ID Verification is Required
When an order requires ID verification:
- First checks if the order is already shipped, cancelled, or in fulfillment (skips if true)
- Updates ShipStation order to your chosen "On Check Created" status (default: On Hold)
- Adds an internal note: "ID verification required"
- Prevents the order from shipping until verification completes
### When ID Verification Passes
When the customer successfully completes verification:
- First checks if the order is already shipped or cancelled (skips if true)
- Updates ShipStation order to your chosen "On Check Passed" status (default: Awaiting Shipment)
- Adds an internal note: "ID verification passed"
- The order can now be fulfilled normally
### When ID Verification Fails
When verification fails:
- First checks if the order is already shipped or cancelled (skips if true)
- Updates ShipStation order to your chosen "On Check Failed" status (default: Cancelled)
- Adds an internal note: "ID verification failed"
- The merchant can decide how to proceed
### Edge Cases Handled
**Late ID Verification**: If a customer completes ID verification after their order has already been cancelled or shipped, the integration will skip the update and log this event. You'll see a note in the ID check events explaining what happened.
**Orders Already Being Packed**: If an order is already in "Awaiting Shipment" status when an ID check is created, it won't be reverted back to "On Hold". This prevents disrupting your warehouse operations.
## Order Status Protection
The ShipStation integration includes comprehensive safeguards to ensure ID verification never disrupts your fulfillment operations. Understanding these protections helps you confidently use the integration without worrying about interference with your shipping workflow.
### Protected Order States
The integration will **automatically skip updates** for orders in these states:
#### 1. Shipped Orders (Status ID: 4)
- **Why it's protected**: Once an order is marked as shipped in ShipStation, it represents a completed fulfillment transaction
- **What happens**: If ID verification completes after shipping, no update occurs
- **Event logged**: "Order [ID] is in a final state (Shipped) and will not be updated"
- **Use case**: Prevents confusion when customers complete verification after receiving their order
#### 2. Cancelled Orders (Status ID: 5)
- **Why it's protected**: Cancelled orders represent a business decision that shouldn't be reversed automatically
- **What happens**: ID verification results won't change cancelled status
- **Event logged**: "Order [ID] is in a final state (Cancelled) and will not be updated. Note: ID verification passed but order was already cancelled."
- **Use case**: Maintains order history integrity and prevents resurrection of cancelled transactions
#### 3. Orders Being Fulfilled (Status ID: 2 - Awaiting Shipment)
- **Why it's protected**: Orders in active fulfillment shouldn't be disrupted
- **What happens**: New ID checks won't revert these orders back to "On Hold"
- **Event logged**: "Order [ID] is already in fulfillment and will not be reverted to hold"
- **Use case**: Prevents warehouse confusion when packing is already underway
### How Protection Works
When any ID verification event occurs, the integration follows this decision flow:
1. **Fetch Current Status**: Retrieves the order's current status from ShipStation
2. **Check Protection Rules**: Determines if the order is in a protected state
3. **Skip or Proceed**:
- Protected states: Logs the skip reason and takes no action
- Non-protected states: Proceeds with the configured status update
### Viewing Protected Order Events
All protection decisions are transparently logged in the ID check's event timeline:
1. Navigate to the ID check details in your Shopify admin
2. Scroll to the Events section
3. Look for events with type "shipstation-order-sync-skipped"
4. These events explain why an update was skipped
1. Navigate to the ID check details in your WooCommerce admin
2. Scroll to the Events section
3. Look for events with type "shipstation-order-sync-skipped"
4. These events explain why an update was skipped
### Common Scenarios
**Scenario 1: Late Verification**
- Customer places order requiring ID verification
- Merchant manually ships order before verification completes
- Customer later completes ID verification
- Result: Order remains "Shipped", skip event is logged
**Scenario 2: Quick Cancellation**
- Order requires ID verification
- Customer requests cancellation
- Merchant cancels in ShipStation
- Customer attempts ID verification
- Result: Order remains "Cancelled", skip event is logged
**Scenario 3: Fast Fulfillment**
- Order initially doesn't require ID (under threshold)
- Merchant begins fulfillment (Awaiting Shipment)
- Manual ID check is created later
- Result: Order remains "Awaiting Shipment", not reverted to hold
### Customizing Protection Behavior
While the core protections cannot be disabled (by design), you can:
1. **Adjust Status Mappings**: Configure which statuses are applied for non-protected orders
2. **Use Manual Overrides**: Manually update orders in ShipStation when needed
3. **Monitor Skip Events**: Use the event log to identify patterns and adjust your workflow
## Frequently Asked Questions
### How are orders matched between my store and ShipStation?
Real ID searches for orders in ShipStation using the Shopify order name (e.g. `#1001`) as the external reference. If you've configured an order prefix, it will be prepended to the order name during the search.
Real ID searches for orders in ShipStation using the WooCommerce order ID as the external reference. If you've configured an order prefix, it will be prepended to the order ID during the search.
### What happens if an order isn't found in ShipStation?
A new order won't be updated until it has imported into ShipStation. If Real ID runs a sync before the order appears, it **doesn't give up** — it automatically waits and retries until the order shows up, then applies the status update. No action is needed on your part.
Shopify orders usually appear in ShipStation within a few minutes. Real ID retries over roughly the next hour and a half, so even a brief import delay is handled automatically.
The WooCommerce → ShipStation connector imports orders on a schedule (commonly hourly), so a brand-new order may not appear in ShipStation for up to about an hour. Real ID accounts for this: it starts a little later and retries with increasing spacing over a longer window of a few hours, so the status update lands once the order finishes importing.
If a status update seems to be taking a while for a fresh WooCommerce order, this import delay is the usual cause — the update will apply on its own once ShipStation receives the order.
### Can I disable certain status updates?
Yes, you can leave any status mapping blank in the settings to disable that particular update. For example, if you don't want to automatically cancel failed orders, leave the "When ID Check Fails" field empty.
### How do I know if the integration is working?
Each ShipStation action is logged as an event on the ID check. You can view these events in the check details to see exactly what happened with the ShipStation integration.
### The ShipStation order status isn't updating, what should I check?
1. Verify the integration is enabled in Settings > Developer Tools
2. Check that your API credentials are correct using the "Test Connection" button
3. Ensure the order exists in ShipStation with the correct external reference
4. Check if you're using an order prefix and have it configured correctly
5. Review the events on the ID check for any error messages
6. Make sure there aren't multiple ShipStation orders for a single corresponding Shopify order
7. Review the order's status in ShipStation — if it's in a final state such as `cancelled` or `shipped`, then Real ID cannot update it
1. Verify the integration is enabled in settings
2. Check that your API credentials are correct using the "Test Connection" button
3. Ensure the order exists in ShipStation with the correct external reference
4. Check if you're using an order prefix and have it configured correctly
5. Review the events on the ID check for any error messages
6. Make sure there aren't multiple ShipStation orders for a single corresponding WooCommerce order
7. Review the order's status in ShipStation — if it's in a final state such as `cancelled` or `shipped`, then Real ID cannot update it
---
// File: js
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# JavaScript SDK
You can use the Real ID JavaScript SDK for advanced custom use cases to trigger ID checks without relying on the built-in triggers available in the [before checkout flow](./flows/before-checkout.mdx).
The JS SDK lets you to programmatically require ID verification gates at any time on the frontend of your site. This includes using it as an alternative to platform-specific checkout extensions for implementing ID verification during checkout on any platform — use `mode: "modal"` to gate a checkout button until the customer has verified their identity.
## Getting Started
If you have the [before checkout flow enabled](./flows/before-checkout.mdx) and are working with an Online Storefront page in Shopify or WooCommerce, then SDK will be included automatically.
But if you have no automatic verification enabled or are working on a custom page outside of the online store, then you'll need to install the SDK on your site. Include the script tag to install it:
```html
```
Then this script tag will load the `RealID` object into your browser window.
:::tip
You'll need to use an HTTPS server for a secure connection in order to properly load the assets for the SDK as well as access the customers camera during verification.
:::
### Authentication
On **Shopify**, **WooCommerce**, and **BigCommerce** storefronts, the SDK automatically identifies your store — no additional authentication is needed.
For **custom websites** or any page where the SDK can't auto-detect your store, pass your `publicKey` to authenticate:
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
publicKey: "pk_your-public-key-here",
});
```
The `publicKey` is a client-safe key that identifies your Real ID account. You can find it in your Real ID dashboard under **Settings > DevTools**.
:::warning Keep your keys separate
The `publicKey` is safe to include in frontend code — it can only be used to create and load ID checks for your account. Your **API token** (used for the [REST API](./api/authentication.md)) is a secret and should never be exposed in client-side code.
:::
### Creating an ID verification gate
Real ID supports two separate modes for prompting ID verification from your customers.
You can simply display the ID check as an element, or you can either override a button or element that requires ID verification, such as a checkout or form submission button.
- `full` mode - embed the entire ID verification prompt directly in the current page
- `modal` mode - replace the target element with an ID verification button, then after the customer is verified or manually approved, show the original element such as a checkout or form submission button again.
### `full` Mode Example
```javascript
// Create a new ID verification wizard
RealID.createFlow({
// this will display the ID verification wizard immediately on the target.
target: "#real-id-mount",
mode: "full",
});
```
### `modal` Mode Example
You can initialize a new ID verification prompt by using the `RealID.createFlow` method. This method accepts a `target` which will be used to replace the target with the ID verification prompt.
After the customer verifies their ID, then they'll be able to see the `target` element again.
```javascript
// Create a new ID verification gate
RealID.createFlow({
// override the Checkout button until the customer is verified
target: ".checkout-btn",
mode: "modal",
});
```
Real ID will automatically replace all elements with an ID verification prompt.
:::info Works on any platform
The JS SDK works on any website — including Shopify, WooCommerce, BigCommerce, and custom-built sites.
:::
### Removing the ID verification gate
You can also remove the ID verification gate by calling `RealID.unmount()`.
This will unmount all Real ID flow instances on your frontend immediately, and will restore the `target` elements.
```javascript
// immediately remove the ID gates from the page and restore any hidden elements
RealID.unmount();
```
## Loading in a specific check
:::info Only for advanced use cases
Real ID JS SDK will automatically create the ID check and associate it with the currently logged in user for you. You typically do not need to use the REST API to create an ID check manually and pass it to the JS SDK.
Passing an ID check manually overrides this behavior, and it's only recommended for advanced use cases like invalidating past approved ID checks on a custom schedule.
:::
By default, the Real ID JS SDK will create an ID check on behalf of the customer. If the customer is logged in, it will automatically pull in their customer ID and will automatically populate their email address and name into the ID check.
Then if the customer returns to this page later, their ID check will be automatically retrieved based on their browser cookies or account details. [Find more details about this process here](./flows/remember-repeat-customers.mdx#before-checkout-flow). This helps by making sure the customer only has a single ID check by default.
However, if you need more control - such as expiring IDs or requiring customers to verify again before a specific event, then you can pass a `checkId` parameter to load a specific ID check.
You can use our [REST API to create a check programmatically](./api/checks.mdx), which will return the `checkId` that you can use to pass to the JS SDK options like so:
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
// always load this specific ID check
checkId: `abc123`,
});
```
:::tip Create checks from the browser
You can also create a check client-side with
[`RealID.createCheck()`](#creating-a-check-without-ui-createcheck) — it returns the
`checkId` without rendering any UI, so you can pass it to `createFlow` or redirect the
customer to the hosted flow yourself.
:::
:::info Fallback behavior
If `checkId` is null or an empty string, then the SDK will fallback to the normal behavior of looking up or creating a new ID check based on the currently logged in customer's information.
However, if the `checkId` is invalid, then a new ID check will not be created and the customer will be prompted to enter in their email address to load their ID check.
For best results, please be certain that the `checkId` is a valid ID check token or you safely provide a `null` or empty string.
:::
### Loading the customer's current ID check
If you are passing the customer's ID to the [create ID check REST API endpoint](./api/checks.mdx), then you can use [WooCommerce meta](./woocommerce/metadata.md) or [Shopify metafields](./shopify/metafields.md) to load the customer's check ID:
Use the `check_id` [stored by Real ID](./shopify/metafields.md#real_idcheck_id-metafield) on your customers accounts.
```javascript
// in a liquid template
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
// always load this specific ID check
checkId: "{{ customer.metafields.real_id.check_id }}",
});
```
Use the `real_id_check_id` stored in the [current user's meta by Real ID](./woocommerce/metadata.md#accessing-the-current-users-metadata-in-php).
```javascript
// in a PHP template
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
// always load this specific ID check
checkId:
"",
});
```
Use the `realid.check_id` [metafield](./bigcommerce/metadata.md#realidcheck_id-metafield) stored on the customer profile.
```javascript
// Fetch the check ID from BigCommerce customer metafields via your server
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
// load the customer's existing ID check
checkId: customerCheckId, // retrieved from the BigCommerce Metafields API
});
```
Retrieve the check ID you [stored in your database](./api/checks.mdx#finding-the-check-id-for-a-customer-or-order) when the check was created via the REST API.
```javascript
// Pass the check ID you stored when creating the check
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
// load the customer's existing ID check
checkId: customerCheckId, // retrieved from your database
});
```
:::tip External database supported
If you store customer accounts on a database outside of Shopify or WooCommerce, then you can use this method to retrieve the customer's ID check token and render their ID check on your site.
:::
## Prepopulate customer details
You can prepopulate customer information to reduce friction during the verification process. When provided, these fields will be automatically filled in for the customer.
### Available Fields
| Parameter | Type | Description |
| ----------- | -------- | ------------------------ |
| `email` | `string` | Customer's email address |
| `firstName` | `string` | Customer's first name |
| `lastName` | `string` | Customer's last name |
| `phone` | `string` | Customer's phone number |
### Basic Example
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
email: "customer@example.com",
firstName: "John",
lastName: "Doe",
phone: "+1-555-0123",
});
```
### Platform-Specific Examples
Use Liquid variables to pass customer data from logged-in accounts:
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
email: "{{ customer.email }}",
firstName: "{{ customer.first_name }}",
lastName: "{{ customer.last_name }}",
phone: "{{ customer.phone }}",
});
```
Use PHP to retrieve customer data from the current user:
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
email: "user_email; ?>",
firstName:
"",
lastName:
"",
phone:
"",
});
```
Use Handlebars or Stencil helpers to pass customer data:
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
email: "{{customer.email}}",
firstName: "{{customer.name}}".split(" ")[0],
lastName: "{{customer.name}}".split(" ").slice(1).join(" "),
phone: "{{customer.phone}}",
});
```
Pass customer data from your own application or templating engine:
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
email: currentUser.email,
firstName: currentUser.firstName,
lastName: currentUser.lastName,
phone: currentUser.phone,
});
```
:::tip Automatic Detection
On **Shopify**, if you're using [Customer Fields by Helium](https://apps.shopify.com/customr), customer data is automatically extracted without any configuration needed.
On **WooCommerce**, logged-in customer data is automatically detected from the current user session.
SDK-provided values always take priority over auto-detected values.
:::
## Cross-checking addresses
You can provide billing and shipping address data to enable [cross-checking rules](./rules/cross-checking-orders.md) that compare the verified ID against order information.
:::info
For Canadian based merchants, the **Shipping Address** is also considered for age verification. The shipping province (a.k.a `state`) and `country` fields are used to determine which age restrictions are used.
If no shipping address is provided, the issuing province of the verified ID is used.
:::
### Available Address Fields
| Parameter | Type | Description |
| ----------- | -------- | -------------------------------------------- |
| `firstName` | `string` | First name on the address |
| `lastName` | `string` | Last name on the address |
| `address1` | `string` | Street address line 1 |
| `address2` | `string` | Street address line 2 (optional) |
| `city` | `string` | City |
| `state` | `string` | State/province code (e.g., "CA", "NY") |
| `country` | `string` | 2-letter ISO country code (e.g., "US", "CA") |
### Example
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
email: "customer@example.com",
firstName: "John",
lastName: "Doe",
billingAddress: {
firstName: "John",
lastName: "Doe",
address1: "123 Main St",
city: "Los Angeles",
state: "CA",
country: "US",
},
shippingAddress: {
firstName: "John",
lastName: "Doe",
address1: "456 Oak Ave",
city: "San Francisco",
state: "CA",
country: "US",
},
});
```
### Supported Cross-Checking Rules
When address data is provided, the following cross-checking rules can be applied after ID verification:
| Rule | Required Fields |
| ---------------------- | ------------------------------------------------------- |
| Billing Name Match | `billingAddress.firstName`, `billingAddress.lastName` |
| Shipping Name Match | `shippingAddress.firstName`, `shippingAddress.lastName` |
| Billing Address Match | `billingAddress.address1`, `city`, `state`, `country` |
| Shipping Address Match | `shippingAddress.address1`, `city`, `state`, `country` |
:::info Cross-checking is optional
Both `billingAddress` and `shippingAddress` are optional. You can provide one, both, or neither. Cross-checking rules will only run if the corresponding address data is available and the rule is enabled in your shop settings.
:::
## Rules
The `rules` parameter lets you control verification behavior directly from the SDK. These options override the default server-side behavior for the current flow instance.
### Available Rules
| Parameter | Type | Default | Description |
| ------------- | --------- | ------- | --------------------------------------------------------------------------- |
| `emailLookup` | `boolean` | `true` | Whether to look up prior ID checks by email and prompt 2FA for repeat customers |
### `rules.emailLookup`
By default, when a customer starts an ID verification flow, Real ID checks if there's already a completed or in-progress ID check associated with their email address. If one is found, the customer is prompted to confirm their identity via a 2FA code sent to their email — rather than creating a new check.
Setting `emailLookup: false` disables this behavior, so every `createFlow()` call creates a fresh ID check regardless of whether the customer has verified before.
**When to use this:**
- You're using the SDK to trigger verification for a specific event (e.g., a high-value purchase) and always want a new check
- You manage check lifecycle yourself via the REST API and `checkId`
- You don't want returning customers to be prompted with a 2FA email challenge
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "full",
email: "customer@example.com",
rules: {
emailLookup: false, // always create a new check, never return a prior one
},
});
```
:::info Default behavior preserved
When `rules` is omitted or `emailLookup` is `true`, the SDK behaves exactly as before — repeat customers are detected by email and prompted to confirm via 2FA. The [remember repeat customers](./flows/remember-repeat-customers.mdx) flow is unaffected.
:::
:::tip Other lookup methods are unaffected
`emailLookup: false` only skips the email-based duplicate check lookup. If a `checkId` is passed, that check is still loaded directly. Customer ID lookups (for logged-in Shopify/WooCommerce users) and checkout session lookups are also unaffected.
:::
## Theming
The JS SDK supports theme customization through the `theme` parameter, allowing you to override default behaviors and content.
### Theme Configuration
```javascript
RealID.createFlow({
target: "#real-id-mount",
mode: "modal",
// Changing the verified button to redirect to a specific URL
theme: {
verified: {
button: {
content: "Continue to Checkout",
url: "https://yourstore.com/checkout",
},
},
// disabling desktop users from using their desktop camera, and forcing a cross device exchange via a QR code
camera: {
desktop: {
enabled: false,
},
},
},
});
```
### Available Theme Options
#### `theme.verified.button`
Controls the call-to-action button displayed after successful ID verification.
- **`content`** (string, required): The text displayed on the button
- **`url`** (string, required): The URL to redirect to when the button is clicked
**Example:**
```javascript
theme: {
verified: {
button: {
content: "Checkout",
url: "https://mystore.com/checkout"
}
}
}
```
**Default Behavior:**
- If not specified, the button will show platform-specific default text (e.g., "Continue to Checkout" for pre-checkout flows)
- Without a custom URL, users are redirected to platform-specific default locations (checkout page, order status, etc.)
#### `theme.camera.desktop`
Controls the availability of desktop webcam option during ID verification.
- **`enabled`** (boolean, optional, default: `true`): Whether to show using a webcam as an option on desktop devices
**Example:**
```javascript
theme: {
camera: {
desktop: {
enabled: false; // Hide desktop webcam option, force mobile QR scan
}
}
}
```
**Use Cases:**
- **Security-conscious environments**: Disable desktop cameras for compliance
- **Mobile-first experience**: Encourage better photo quality through mobile capture
- **Technical limitations**: When desktop webcam quality is insufficient
**Behavior:**
- When `enabled: true` (default): Desktop users see QR code scan, desktop webcam, and manual upload options
- When `enabled: false`: Desktop users only see QR code scan and manual upload options
- Mobile devices are unaffected by this setting
#### `theme.autoScroll`
Controls whether the SDK automatically scrolls to the verification widget on initial load and between steps.
- **`disabled`** (boolean, optional, default: `false`): Set to `true` to prevent all auto-scrolling
**Example:**
```javascript
theme: {
autoScroll: {
disabled: true // Prevent auto-scrolling to the widget
}
}
```
**Use Cases:**
- **Custom scroll behavior**: You manage scroll position yourself after mounting the widget
- **Single-page applications**: Avoid unexpected scroll jumps in SPA layouts
- **Inline embeds**: The widget is already visible and scrolling would be disorienting
**Behavior:**
- When `disabled: false` (default): The page scrolls to the widget on load and after each verification step
- When `disabled: true`: No automatic scrolling occurs — the widget renders in place without affecting scroll position
### Theme Priority
Theme settings follow this priority order (highest to lowest):
1. **JS SDK theme parameter** - Passed directly to `createFlow()`
2. **Shop settings theme** - Configured in the Real ID app dashboard
3. **Default platform behavior** - Built-in fallbacks
This means JS SDK theme options will always override shop-level theme settings.
### Complete Example
```javascript
RealID.createFlow({
target: ".checkout-button",
mode: "modal",
theme: {
// Customize the success button
verified: {
button: {
content: "Complete Your Purchase",
url: "https://mystore.com/checkout?verified=true",
},
},
// Disable desktop webcam for security
camera: {
desktop: {
enabled: false,
},
},
// Disable auto-scrolling to the widget
autoScroll: {
disabled: true,
},
},
});
```
::: Additional customizations available
We can help add additional theme options and customizations. [Please contact us](https://getverdict.com/contact) if you need additional configuration or settings.
:::
## Events
The JS SDK dispatches custom events on `window` when an ID check completes. You can listen for these events to trigger your own logic — for example, enabling a checkout button, redirecting the customer, or sending events to your analytics platform.
### Available Events
| Event Name | When It Fires |
| ---------------------- | ---------------------------------------------------------------------------------------- |
| `real-id-check-loaded` | A check has been loaded or created and is now available — fired before the customer verifies |
| `real-id-check-passed` | The customer's ID check completed successfully and passed all rules |
| `real-id-check-failed` | The customer's ID check failed automated verification or was sent for manual review |
All events are standard [`CustomEvent`](https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent) instances dispatched on the global `window` object.
### Listening for Events
Attach a listener to `window` to react to the verification lifecycle:
```javascript
window.addEventListener("real-id-check-loaded", (event) => {
const { check } = event.detail;
console.log("ID check available", check.id);
// e.g. record the check ID, populate hidden form fields, fetch related order data
});
window.addEventListener("real-id-check-passed", (event) => {
const { check } = event.detail;
console.log("ID check passed", check.id);
// e.g. enable a checkout button, redirect, or report to analytics
});
window.addEventListener("real-id-check-failed", (event) => {
const { check } = event.detail;
console.log("ID check failed", check.id, "step:", check.step);
// e.g. show a custom error message or route to your support flow
});
```
All event payloads use `snake_case` field names to match the [REST API response format](./api/checks.mdx#example-response).
### Event Payload
Each event delivers the same shape on `event.detail`, matching the [REST API `GET /api/v1/checks/:checkId`](./api/checks.mdx#example-response) envelope:
```javascript
{
check: {
id: "abc123",
step: "completed", // or "in_review"
shop_name: "my-store.myshopify.com",
platform: "shopify", // "shopify" | "wc" | "bc"
order: {
id: null, // Shopify admin GraphQL id or WC order id
name: null, // order display name / number
},
customer: {
first_name: "Jane",
last_name: "Smith",
email: "jane@example.com",
phone: null,
},
rules: {
testing: false, // true when the check is in sandbox mode
signature_required: false,
id_check_type: "idv", // "id" | "idv"
include_back_of_id: false,
selfie_liveness: "straight",
},
result: {
success: true, // false for failed checks, undefined before verification
},
}
}
```
:::info Private details are not available in the JS SDK
The customer's PII extracted from their ID (document number, date of birth, address, verification scores, photos) is not accessible through the client-side JS SDK. To retrieve this information, use the [REST API](./api/checks.mdx) over a secure server-to-server connection.
:::
### `real-id-check-loaded`
Fired as soon as the SDK has loaded or created an ID check for the customer. This happens before the customer has captured their ID — it's the earliest point at which a `check.id` is available.
This event also re-fires after a 2FA confirmation refreshes the check, or after the SDK retrieves the latest state from the API.
Use this event when you want to:
- Capture the `check.id` so you can correlate it with your own systems (orders, sessions, analytics)
- Pre-populate hidden form fields with the check token
- Detect whether the check is already in a terminal state (e.g., a returning verified customer)
```javascript
window.addEventListener("real-id-check-loaded", (event) => {
const { check } = event.detail;
// Store the check ID for later reference
document.getElementById("real-id-check-id-input").value = check.id;
// Returning customer who has already verified
if (check.step === "completed" && check.result?.success) {
console.log("Customer already verified");
}
});
```
### `real-id-check-passed`
Fired when **both** conditions are true:
- `check.step === "completed"`, and
- `check.job.result.success === true`
This is the canonical success signal — the ID was verified and any [cross-checking rules](./rules/cross-checking-orders.md) were satisfied.
:::info Modal mode unmounts before the event fires
In `mode: "modal"`, the SDK unmounts the flow and restores the original target element before dispatching `real-id-check-passed`. By the time your listener runs, the target (e.g., a checkout button) is already visible again.
:::
### `real-id-check-failed`
Fired when **either** condition is true:
- `check.step === "in_review"` (the check needs manual merchant review), or
- `check.job.result.success` is falsy (automated verification rejected the ID)
Inspect `check.step` to distinguish between a hard failure and a soft "pending review" state:
```javascript
window.addEventListener("real-id-check-failed", (event) => {
const { check } = event.detail;
if (check.step === "in_review") {
// Awaiting manual review by the merchant
showMessage("Thanks — your ID is being reviewed. We'll email you shortly.");
} else {
// Automated verification rejected the ID
showMessage("We couldn't verify your ID. Please try again or contact support.");
}
});
```
### Complete Example
Gate a custom checkout button until the customer passes verification:
```html
```
### Accessing the current check synchronously
If you need to read the current check outside of an event handler — for example, in code that runs after the customer has already verified, or to check state on demand — call `RealID.getCheck()`:
```javascript
const check = RealID.getCheck();
if (check) {
console.log("Current check:", check.id, "step:", check.step, "success:", check.result?.success);
} else {
console.log("No check has been loaded yet");
}
```
`RealID.getCheck()` returns the same public check object that's delivered in the events — or `null` if no check has been loaded in this session yet. It's updated whenever `real-id-check-loaded`, `real-id-check-passed`, or `real-id-check-failed` fires.
:::info Last-write-wins across multiple flows
If a page mounts more than one flow (for example, a "Buy it now" button and a side cart), `RealID.getCheck()` returns the most recently updated check. The completed check takes precedence over an in-progress one.
:::
:::tip Pair the accessor with the load event
For code that loads after the SDK has already started, listen for `real-id-check-loaded` to be notified of new checks, and use `RealID.getCheck()` to read state at any point afterward.
:::
## Creating a check without UI (`createCheck`)
`RealID.createCheck()` creates an ID check and returns it **without rendering any
verification UI**. Use it when you want to own the experience yourself — for example, on a
headless checkout, create the check and then send the customer to the dedicated hosted
flow with your own styled button.
```javascript
const result = await RealID.createCheck({
publicKey: "pk_your-public-key-here",
email: "customer@example.com",
});
if (result.status === "verification_required") {
// result.url is the ready-to-use hosted-flow URL for this check
window.open(result.url, "_top");
}
```
This is the SDK-native equivalent of how the Shopify during-checkout extension works: it
creates the check, then links the customer out to the hosted flow. See
[Responses](#responses) below for the full set of `result.status` values.
:::tip Authentication
On **Shopify**, **WooCommerce**, and **BigCommerce** storefronts the SDK auto-detects your
store. On **custom or headless** sites, pass your client-safe `publicKey` (see
[Authentication](#authentication)).
:::
### Options
| Parameter | Type | Description |
| ------------------- | --------- | ---------------------------------------------------------------------------------------------------------------------- |
| `publicKey` | `string` | Required on custom/headless sites to identify your Real ID account |
| `email` | `string` | Customer's email address |
| `firstName` | `string` | Customer's first name |
| `lastName` | `string` | Customer's last name |
| `phone` | `string` | Customer's phone number |
| `billingAddress` | `object` | Billing address for [cross-checking rules](#cross-checking-addresses) |
| `shippingAddress` | `object` | Shipping address for [cross-checking rules](#cross-checking-addresses) |
| `theme` | `object` | Flow theme (same shape as [`createFlow`](#theming)). Saved on the check and applied when the customer reaches the hosted flow at `result.url`. See the note below. |
| `rules.emailLookup` | `boolean` | Defaults to `false` for `createCheck` — always create a fresh check. Set `true` to look up returning customers (may require 2FA). |
:::info Setting `theme` on a headless check
`createCheck` renders no UI, so `theme` has no immediate effect on the call itself. It's saved on the check and applied when the customer reaches the hosted flow at `result.url` — where `theme.verified.button.url` becomes the return URL after verification and `theme.verified.button.content` sets the button label. See [Theming](#theming) for the full shape.
For your customers' security, only an `https://` return URL is honored — other URLs are ignored.
:::
### Responses
`createCheck()` **always resolves to a result object** — it never throws for a known
outcome. Switch on `result.status` to decide whether to let the customer continue to
checkout or send them to verify:
| `result.status` | Payload | What it means | Recommended action |
| ----------------------- | ------------------ | ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------- |
| `verification_required` | `check`, `url` | A check was created, or an unfinished one already exists | Send the customer to `result.url` |
| `already_verified` | `check`, `url` | The customer has already completed and passed verification | **Allow checkout** |
| `not_required` | `reason?` | Your rules didn't require verification for this customer | **Allow checkout** |
| `requires_2fa` | `email` | A returning customer matched by email (only when `emailLookup: true`) | Send them to the hosted flow to confirm via 2FA, or re-call with `rules.emailLookup: false` |
| `error` | `code`, `message?` | Shop not found, a server error, or a network error | Block, or fail-open, per your policy |
The `check` payload uses the same shape as the [event payload](#event-payload) and
`RealID.getCheck()`. A successful `createCheck()` also updates `RealID.getCheck()` and
dispatches the [`real-id-check-loaded`](#real-id-check-loaded) event.
:::tip Use `result.url` instead of building the URL yourself
For the two check-bearing statuses, `result.url` is the ready-to-use hosted-flow URL for
that check. It automatically reflects your **custom Flow URL** (if your shop sets a
[white-label domain](./theming/white-label-domains.md)) and the current default flow domain
— so you never hardcode `verify.getverdict.com`.
:::
:::info Already verified vs. needs verification
`already_verified` is only returned when the existing check is **completed and passed**
(`check.step === "completed"` and `check.result.success === true`). Any other existing
check — in progress, in review, or failed — resolves as `verification_required`, so you can
send the customer back to finish or view their status.
:::
### Example
```javascript
const verifyBtn = document.querySelector("#verify-id-btn");
verifyBtn.addEventListener("click", async () => {
const result = await RealID.createCheck({
publicKey: "pk_your-public-key-here",
email: "customer@example.com",
firstName: "John",
lastName: "Doe",
});
switch (result.status) {
case "verification_required":
// hand the customer off to the hosted verification flow
window.open(result.url, "_top");
break;
case "already_verified":
case "not_required":
proceedToCheckout(); // let them through
break;
case "requires_2fa":
// returning customer — send them to the hosted flow to confirm, or re-call
// with rules.emailLookup: false to force a brand new check
break;
case "error":
console.error("Real ID:", result.code, result.message);
// block, or fail-open, depending on your risk tolerance
break;
}
});
```
```jsx
"use client";
export function VerifyIdButton({ customer }) {
async function startVerification() {
const result = await RealID.createCheck({
publicKey: process.env.NEXT_PUBLIC_REAL_ID_PUBLIC_KEY,
email: customer.email,
firstName: customer.firstName,
lastName: customer.lastName,
});
switch (result.status) {
case "verification_required":
window.location.href = result.url;
break;
case "already_verified":
case "not_required":
// continue your checkout flow
break;
case "requires_2fa":
// confirm via the hosted flow, or re-run with rules.emailLookup: false
break;
case "error":
console.error(result.code, result.message);
break;
}
}
return ;
}
```
:::info Prefer to create checks server-side?
If you'd rather keep check creation on your backend, use the secret-key
[REST API to create a check](./api/checks.mdx) (`POST /api/v1/checks`), return the `checkId`
to your frontend, and redirect to `https://verify.getverdict.com/{checkId}`. Use
`createCheck()` when you want a client-only integration with your public key.
:::
## Frequently Asked Questions
### How do I know if the Real ID JS SDK is available in the current page in Shopify?
Within your browser's JavaScript console, enter in `window.RealID`. If the result is `undefined`, then that means you need to install the JS SDK on that page.
### Will already verified repeat customers be verified automatically?
Yes, the SDK will automatically detect if the customer is logged in and has already verified their ID. Or if they are not logged in, then the SDK will find their prior ID check from the customer's email address when they start the flow.
The [same methods to remember repeat verified customers for the before checkout flow](./flows/before-checkout.mdx) are used for this SDK.
If you want to disable this behavior and always create a fresh check, use [`rules.emailLookup: false`](#rulesemaillookup).
### Will my theme and rules be applied?
Yes, the Real ID JS SDK will automatically apply the rules, content and theme you've set up in the settings page of the app.
### Can I use this on any website outside of Shopify & WooCommerce?
Yes! The JS SDK works on any website. You can use it to implement ID verification gates on BigCommerce, custom-built sites, or any other platform.
### Will this work within a Liquid Snippet in my Shopify Theme?
Yes, you can write JavaScript within a Liquid Snippet. Depending on if the page you're adding the snippet to is within the Storefront then you can skip the installation step.
### Will this work within a Shopify Checkout Extension?
No, Shopify Checkout Extensions don't allow you to write arbitrary HTML. However, you can use our [Shopify checkout app block](./flows/during-checkout.md) to require ID verification during checkout, or add the block to the [after checkout](./flows/after-checkout.mdx) order status page.
### Can I use this on my WordPress site pages?
Yes, you can add ID verification to any page on your WordPress site, even outside of checkout. [Please see our guide here.](./woocommerce/verification-page.md)
---
// File: rules/adjusting-minimum-confidence
# Adjusting Minimum Confidence
Real ID uses several A.I. models to evaluate the overall confidence of the customer's ID as well as their biometric verification (also known as face matching).
By default, the system requires 90% confidence of quality of the ID image, face image, fatch match probability, and the confidence of reading each individual field from the ID such as name, address, date of birth, date of expiration and more.
However, if you experience a high level of false negatives (incorrectly rejected IDs) or false positivies (incorrectly accepted IDs), then you can adjust the minimum overall confidence to meet your needs.
## Getting started
First, open the **Settings** page in the Real ID app. Then navigate to the **Rules** tab.
Here are the various rules you can set for ID checks. Scroll down to the **Confidence Threshold** section.

Here you can adjust the overall confidence needed for an ID to be considered a pass.
Lowering the confidence will allow more IDs to be accepted, and reduce the confidence needed for reading the fields on the ID document, as well as lower the face matching confidence.
You might want to lower the confidence threshold if you're requiring ID verification before checkout, so that way customers can still place their order even if they're unable to take high quality photos of their ID. Then before fulfillment you can review their submissions if neccessary.
Raising the confidence will make ID verification more strict, it will only accept the highest quality images, and require a higher degree of certainty to accept the photos.
Lowering or raising the confidence threshold only applies to the automatic verification of IDs, you and your staff can [still override the results at any time in the app](../for-merchants/overridding-results.md).
:::note
Please note, A.I. can still make mistakes. We still highly recommend reviewing individual cases for high risk orders or customers.
:::
---
// File: rules/age-verification
# Age Verification
You can require a minimum age requirement for ID checks to pass on your store.
Real ID will read the date of the birth on the customer's ID and verify it meets the minimum age requirements for your store.
If an ID does not meet your minimum age criteria, the ID check will fail automatically.

## Setting a minimum age
To set a minimum age, open the **Settings** page and open the **Rules** tab.
Scroll down to the **Age Requirements** section. Here you can define the minimum age required to pass an ID check on your store.
You can specify 18+, 21+ or a custom age that fits your needs.
### U.S. and Canadian Legal Smoking ages
We have a specific rule set to cover the U.S. and Canadian tobacco requirements. For example, Canadian age restrictionso on tobacco products vary per provice.
With this rule enabled, Real ID will require submitted IDs to match the minimum age requirement based on the shipping address of the order.

:::note Before checkout
If your store has an [ID gate before checkout](../flows/before-checkout) set up, then the ID age requirement will be based off of the customer's province on their ID document.
This is because at this point there is no order to compare a shipping address against.
:::
## Frequently asked questions
### How does it work?
After Real ID has verified the details of the ID document and applied the face match, then it will verify that the customer's age based on the **Date of Birth** field on the verified document meets your minimum age requirement.
### Can I apply age verification to only certain products or collections of products?
[Yes, you can first filter which products require ID verification](../triggers/specific-products.mdx), then you can set a minimum age for those ID checks.
### Do these minimum age requirements also apply to ID checks sent manually?
Yes, these minimum age requirements will apply to all ID checks, including those sent manually.
### Can I split minimum age requirements across different products and categories?
No, at this time minimum age checks apply to all ID checks, regardless of which rule triggered them.
---
// File: rules/automatic-retries
# Automatic Retries
If customers failed to pass ID verification on their first attempt, you can set Real ID to automatically send them another ID check to try again.
This helps customers self serve another chance at ID verification on their order that might have uploaded blurry or unreadable IDs on their first try.
A new retry creates a brand new ID check, separate from their first attempt.
Real ID will only send another ID check to the customer if:
- The customer failed their first ID check
- The number of customer's retries are under your maxmium limit
Real ID will **not** send an automatic retry if:
- The customer failed their ID check due to being underage
- The customer passed one of their ID checks
- The ID check isn't associated with a customer profile
- The ID check is manually rejected by one of your staff
:::note
At this time, this feature is only available on Shopify.
:::
## Getting Started
To enable this feature, first open the **Settings** area of the Real ID app, then open the **Rules** tab. Scroll down to the **Automatic Retires** section an toggle it on to enable it.
### (Optional) Increase the number of maximum allowed retries
By default, enabling this setting allows the customer to retry one more time after failing their initial ID check.
For example, if the maximum number of retries is set to 2, then the customer is given 2 more retries after their first attempt for a total of 3 ID check attempts.
### (Optional) Modify the retry email and subject lines
You can customize the content of the email content to the customer that contains their new ID check link.
The subject and email body are applied to the retry ID checks only. Your exisiting branding and theme set by the Appearance settings are applied as well.
The ID check link will be included within the email automatically.
## Frequently Asked Questions
### Do retries incur additional ID check usage fees?
Only if the customer participates in a retried ID check does it result in a fee. If the customer doesn't participate, there is no fee.
---
// File: rules/back-of-id-capture
# Back of ID Capture
Many IDs carry critical information on the back — addresses, expiration dates, machine-readable zones, and additional security features. Real ID can capture and analyze the back of an ID alongside the front, and you control when this happens with three capture modes.
## Enabling Back of ID Capture
Open the **Settings** page in the Real ID app, then select the **Rules** section. Scroll down to the *Back of ID Capture* section and choose one of the three modes below.
## Capture modes
### Automatic (default)
Real ID detects when the document type has additional fields on the back — such as German identification cards, or driver's licenses where the address is printed on the reverse — and only then prompts the customer to capture it.
This is the recommended mode for most merchants: it minimizes customer friction while still capturing the back where it actually matters.
### Always
Every customer is prompted to capture the back of their ID, regardless of document type.
Choose this when you want the most complete record on every verification — for example, if you store the photos for compliance or audit purposes, or if you process IDs from many regions and prefer consistent data.
### Never
The back of the ID is never requested, even for document types that would normally have data on the back.
Choose this for the fastest customer experience when the front of the ID is sufficient for your use case.
## Frequently Asked Questions
### Which document types require a back capture in Automatic mode?
Documents with information beyond what's printed on the front — most non-US national ID cards, certain European driver's licenses (e.g. German), and similar documents. Real ID detects the document type from the front of the ID and only prompts for the back when the document needs it.
### Will switching modes affect existing checks?
No. Mode changes only apply to new checks created after the change. In-progress and completed checks are unaffected.
### Can the customer skip the back capture?
No. If the selected mode requires it, the verification cannot complete without the back of the ID.
### Where can I view the captured back of ID?
The back of the ID appears alongside the front on the check details page, and is included when [downloading customer photos](../for-merchants/downloading-customer-photos.md).
---
// File: rules/capturing-e-signatures
# Requiring an eSignature during the ID check
You can optionally require signature capture as part of the customer's ID verification. Your customers will be prompted with an intuitive and easy to use canvas that will allow them to draw their signature with their finger or a stylus on their mobile device.

## How to enable eSignatures
You can enable or disable Real ID to require electronic signatures as part of the ID verification process at any time. There is no code required to complete this step.
To enable it, open the **Settings**"* page, then open the **Rules** tab and select the **Require eSignature** checkbox. Click the **Save** button in the top right to apply the change.

## Where can I view eSignatures?
After customers sign for the ID check, the signature will be available in the Real ID dashboard under the ID check details:

## When are electronic signatures captured during the ID check?
If an ID check requires an eSignature, the customer will be prompted to submit a signature before they continue onto the next step.
---
// File: rules/control-capture-methods
# Controlling how IDs are captured
By default, Real ID allows customers to submit their ID photos for verification via their phone's camera, laptop webcam or upload a photo of their ID from their device.
However, you can choose to disable uploading files manually at any time.
Below is an example of an ID check opened on desktop, showing the three different options to submit photos to complete an ID check.

## Reasons for allowing manual photo uploading
There are positives to allowing customers to manually upload their photos instead of using their device's camera for live photo:
- **More inclusive** - Customers without a functioning camera on their laptop or phone will be able to submit ID photos
- **More flexible to missing IDs** - Customers who physically have lost their ID will be able to upload a backup photo
- **More forgiving** - Customers having issues granting permission for Real ID to access their camera during the ID check will have a way to still finish their ID check
Overall, enabling manual ID photo uploads will **increase** your ID check completion rates, but it will **decrease** the quality and security of your ID checks.
## Reasons for disabling manual photo uploading
However, there are trade offs to allowing manual uploading of files. Here are few reasons why you might want to disable it:
- _Higher photo quality_ - requires customers phone or laptop bypasses Real ID's autocapturing feature.
- _Better security_ - only allowing ID photos to be captured from a camera, you ensure that the ID is physically real. It wouldn't be possible to download a selfie from a social network, or download an ID image from the internet and upload it directly.
- _Less failed ID checks_ - since all ID photos will undergo a quality check by Real ID's autocapturing, you'll see a decrease in bad quality or blurry photos
Overall, disabling manual ID photo uploads will increase the quality of all photos, **increase** security, but it will **decrease** the flexibility to end customers with unique circumstances.
---
// File: rules/cross-checking-orders
# Cross Checking Verified IDs to Orders
Real ID can automatically cross-referencing the details from a verified ID with the name and address of billing and/or shipping details. If the addresses or names provided for either the credit card or the shipping address do not match the information on the verified ID, it could be a red flag for potential fraud.
This may also be a requirement for Know Your Customer (K.Y.C.) compliance for your industry. Verifying the identity of customers and cross-referencing address details can help comply with these requirements.
- [Getting started](#getting-started)
- [Cross Checking the Credit Card Name](#cross-checking-the-credit-card-name)
- [Cross Checking Billing Details](#cross-checking-billing-details)
- [Cross Checking the Billing Name](#cross-checking-the-billing-name)
- [Cross Checking the Billing Address](#cross-checking-the-billing-address)
- [Cross Checking Shipping Details](#cross-checking-shipping-details)
- [Cross Checking the Shipping Name](#cross-checking-the-shipping-name)
- [Cross Checking the Shipping Address](#cross-checking-the-shipping-address)
- [Before checkout details](#before-checkout-details)
- [Frequently Asked Questions](#frequently-asked-questions)
- [What's the difference between the billing and credit card details on an order?](#whats-the-difference-between-the-billing-and-credit-card-details-on-an-order)
- [Does the billing name and credit card name need to match on an order?](#does-the-billing-name-and-credit-card-name-need-to-match-on-an-order)
- [Is credit card name matching available on WooCommerce?](#is-credit-card-name-matching-available-on-woocommerce)
- [We're seeing too many falsely flagged name mismatches on the billing, shipping or credit card names](#were-seeing-too-many-falsely-flagged-name-mismatches-on-the-billing-shipping-or-credit-card-names)
## Getting started
To enable automatic cross checking for either billing or shipping details, open **Settings** then open the **Rules** tab.
Scroll down to the **ID to Order Consistency Checks** section to find these settings:

### Cross Checking the Credit Card Name
Real ID can automatically compare the name on the credit card details against the name on the verified ID. To enable this open the _ID to Order Consistency Checks_ section in the **Rules** then:
1. Open the **Settings** page
2. Open the **Credit Card** tab
3. Click the option to require the credit card and ID name to match
4. Choose your preferred **Name Similarity Sensitivity** level
5. Save the changes

:::info Non-credit card payments and multiple cards
If the order isn't paid for with any credit cards, then this rule will be skipped.
Multiple credit cards can be used to pay for a single order. Real ID will compare all credit card names for a given order, if any credit card names do not match the name on the verified ID, then the ID check will be placed in review and flagged.
:::
## Cross Checking Billing Details
During checkout, your customer will input their billing details. Real ID can compare the `name` and `address` fields from the billing details on the order against the `name` and `address` fields on the verified ID.
If the details match, then the ID check will pass automatically, but if the details do not match, then the ID check will fail.
### Cross Checking the Billing Name
Real ID can automatically compare the name on the billing details against the name on the verified ID. To enable this open the _ID to Order Consistency Checks_ section in the **Rules** then:
1. Open the **Settings** page
2. Open the **Billing** tab
3. Click the option to require the billing and ID names to match
4. Choose your preferred **Name Similarity Sensitivity** level
5. Save the changes

:::tip Middle names are considered too
If the ID document and the billing details contains the customer's middle name, then the middle name will be included in the matching of the details.
:::
### Cross Checking the Billing Address
Real ID can automatically compare the name on the credit card details against the address on the verified ID. To enable this open the _ID to Order Consistency Checks_ section in the **Rules** then:
1. Open the **Settings** page
2. Open the **Billing** tab
3. Click the option to require the billing and ID addresses to match
4. Save the change

## Cross Checking Shipping Details
During checkout, your customer will input their shipping details. Real ID can compare the `name` and `address` fields from the shipping details on the order against the `name` and `address` fields on the verified ID.
If the details match, then the ID check will pass automatically, but if the details do not match, then the ID check will fail.
### Cross Checking the Shipping Name
Real ID can automatically compare the name on the shipping details against the name on the verified ID. To enable this open the _ID to Order Consistency Checks_ section in the **Rules** then:
1. Open the **Settings** page
2. Open the **Shipping** tab
3. Click the option to require the shipping and ID names to match
4. Choose your preferred **Name Similarity Sensitivity** level
5. Save the changes

:::tip Middle names are considered too
If the ID document and the billing details contains the customer's middle name, then the middle name will be included in the matching of the details.
:::
### Cross Checking the Shipping Address
Real ID can automatically compare the name on the shipping details against the address on the verified ID. To enable this open the _ID to Order Consistency Checks_ section in the **Rules** then:
1. Open the **Settings** page
1. Open the **Billing** tab
1. Click the option to require the shipping and ID addresses to match
1. Save the change

### Before checkout details
If your store requires ID verification before checkout, Real ID will read billing details the customer enters in the checkout form.
However, if the customer starts ID verification outside of the checkout form, there won't be checkout details to read at the time of ID verification. Even if the customer verifies their ID before they reach the checkout form, Real ID will cross check the billing details on the order after checkout as well.
However, if you require blocking orders and payment capture before checkout completely, remove any buttons that will cause Real ID to prompt for ID verification outside of the checkout page.
:::warning Shopify restricts access to checkout
Shopify does not allow 3rd party apps to access the checkout page. This means that if you require ID verification before checkout, Real ID will not be able to perform the cross checking _before_ the order is placed.
The only exception is for Shopify Plus stores. If you have a Shopify Plus store that requires ID verification & cross checking before the order is placed, [please contact us for help](/contact).
:::
## Frequently Asked Questions
### What's the difference between the billing and credit card details on an order?
The billing details are always present on an order, but the credit card details are not guaranteed. This is because not all orders are paid with credit cards. If you accept cash on delivery, checks, ACH transfers, or buy now pay later options then you may not collect credit card details and only the billing details will be available on the order.
### Does the billing name and credit card name need to match on an order?
No, customers can enter in a different billing name from their name on their credit card. There's no restriction in the checkout to prevent a different name on billing vs credit card. Credit card processors don't consider the billing name when validating the credit card details, they only consider the name on the credit card field in your store's checkout.
### Is credit card name matching available on WooCommerce?
No, at this time the credit card name matching rule is only available for the Shopify version of the Real ID app.
### We're seeing too many falsely flagged name mismatches on the billing, shipping or credit card names
You can adjust the name sensitivity to decrease the number of falsely flagged orders. Decreasing this sensitivity will allow more flexibility with the name matching, but it may increase the number of false positives. We highly recommend keeping the name sensitivity threshold as high as possible, since this rule isn't applied until after checkout, so your team has the time to manually review before deciding to accept the ID and fulfill.
---
// File: rules/expired-id-policy
# Expired ID Policy
You can control how Real ID handles expired ID documents during verification.
By default, Real ID will reject any ID that is expired at the time of verification. If your business needs to accept recently expired IDs or skip expiration checks entirely, you can configure this in your settings.
## Setting an expired ID policy
To configure your expired ID policy, open the **Settings** page and open the **Rules** tab.
Scroll down to the **Expired IDs** section. You'll see three options:
### Reject expired IDs

This is the default setting. Any ID that is expired at the time of verification will be automatically rejected. This is the most restrictive option and is recommended for most stores.
### Accept recently expired IDs

Accept IDs that expired within a grace period you define. For example, if you set a grace period of 30 days, an ID that expired 15 days ago would still pass verification, but one that expired 45 days ago would be rejected.
This is useful for businesses where customers may have recently expired IDs while waiting for a renewal, and the slight expiration doesn't pose a meaningful risk.
### Accept all expired IDs
Expiration dates will not be checked at all. Any ID will pass regardless of its expiration status.
:::note
This setting only affects the **expiration date check** during verification. All other checks (face match, age verification, cross-checking, etc.) still apply normally.
:::
## Frequently asked questions
### Which plan do I need?
The expired ID policy setting is available on the **Essential** plan and above.
### Does this apply to manually sent ID checks?
Yes, the expired ID policy applies to all ID checks, including those sent manually.
### What happens to existing checks if I change this setting?
Changing the policy only affects future ID verifications. Previously completed checks are not re-evaluated.
---
// File: rules/face-match
# Face Match
As part of the ID check, you can also require customers submit a photo of their face (a.k.a. selfie).
This photo will be used to compare against the same photo on the ID using biometrics. If Real ID's A.I. is able to make a high confidence match, then the ID will be accepted.
:::tip Disable manual uploads
We highly recommend [disabling manual file uploads](../rules/control-capture-methods.md) when using this feature.
This helps prevent the use of stolen photos, and requires the customer to take a live photo of themselves.
:::
## Enabling Face Match
To turn on face match for all new ID checks, first open the **Settings** page, then navigate to the **Rules** tab.
Here you can choose between only requiring an ID photo, and requiring an ID and a selfie. Face matching will be enabled automatically if you have enabled the selfie capture.
Don't forget to click **Save** in the top right hand corner to apply these changes.

## Viewing the results
If this feature is enabled, Real ID will require the customer to provide a selfie as part of their ID check, after their ID has been captured.
Then Real ID will automatically compare the profile photo printed on ID against the captured selfie. If the A.I. meets your minimum threshold for confidence (default greater than 90% confidence), then the face match rule will pass.
You will be able to view both the ID and the selfie captured from the customer in the Real ID dashboard for the ID check. Here's an example of the breakdown from passed ID check:

---
// File: rules/proof-of-address
# Proof of Address
You can require additional proof of address documentation from customers as part of their ID check.
Customers will then be able to use their camera or upload (if enabled) proof of address documents such as:
* Internet service bills
* Cell Phone bills
* Utility bills
* Etc.
You'll then be able to use this documentation to match the ID / billing address to the order.
You can enable Proof of Address for all automatically triggered ID checks, or you can choose to require Proof of Address as an additional security layer manually for specific orders.
## Enabling Proof of Address collection
To enable Proof of Address collection for all new customer ID checks, open the **Settings** page in the Real ID app. Then select the **Rules** section.
Scroll down to the *Proof of Address* section to enable it.
After enabling the Proof of Address collection, new customers will be prompted to provide a proof of address documentation in addition to their ID check.
## Frequently Asked Questions
### At what point during the ID check are customers required to provide their proof of address document?
After the customer provides their ID and/or selfie as part of the ID check, then they will be prompted to submit their proof of address documentation.
### What kinds of documents can customers provide?
Customers can upload any proof of address documentation they'd like. The system supports any image format for manual uploads.
### Can I disable manual uploads of Proof of Address documents to help prevent fraud?
Yes, we highly recommend [disabling manual uploads](../rules/control-capture-methods.md) to help prevent fraud.
By requiring the photos to be taken live and not allowing manually uploaded, you'll know that the document is phyiscally present by the customer.
### Can Real ID automatically cross check the utility bill details against the ID or billing address on the order?
At this time no, Real ID will only capture the proof of address on your behalf. But if you need this for your use case, please [contact us for help](https://getverdict.com/contact).
---
// File: rules/sms-verification
---
// File: rules
---
// File: sending-an-id-check
# Sending a new ID check
You can manually send customers ID checks at any time, with or without an order on your store.
To get started click the **New ID check** in the top right or left of the app:

## Choosing the order to verify
Once you have the new ID check form open, you'll be able to search and choose from your recent orders to send ID checks to.
You can use the search bar to filter orders by order number, like `#1001`.
Alternatively, you can filer by the risk level. The risk level is based on the Shopify Fraud Analysis, or other 3rd party apps you have installed that have also added risk analysis to your orders.

:::info
At this time Real ID can only view the past 60 days of order history. If you need to verify an customer's ID from an order that's more than 60 days old, you'll need to type the customer's name and contact information manually.
:::
Once you have found the order you'd like to send an ID check for, click on the order to proceed to the next step:

### Creating from scratch
Alternatively, if the customer hasn't placed an order yet you can still enter in their contact information manually by clicking the **Create from scratch** link:

:::note
Please note that if you decide to send the ID check from scratch the customer nor the order will be [tagged](/docs/shopify/tags) or [metafields](/docs/shopify/metafields) sync'd automatically.
The ID check will not be associated with the customer's actual account or order, but instead the ID check will have their contact information associated only.
:::
### Customizing the ID check content
On the next step, you can customize the ID check's content, you can use short codes to reference the order number as well as by the customer's name.
This content will appear both in the email body sent to the customer and as the introduction screen shown to the customer when they open their unique ID check link in the email.
Your message to the customer might vary depending on if you require ID checks for only high risk orders, for age verification, or K.Y.C. compliance.
:::tip
If you're sending multiple ID checks manually, you can set this default content within your **Settings** under the **Appearance** section.
:::
### Setting ID check requirements
Now, you can select the requirements that customers need to complete in order to pass the ID check.
You can choose between requiring an **ID photo only** or requiring both an **ID photo and headshot**. If you choose the **ID photo and headshot**, then Real ID will verify that the live headshot photo matches the headshot photo physically on the provided ID photo.
After making your choice, click **Next** to continue.
### Reviewing
Finally, you'll receive a summary to confirm the details of the ID check before it's sent.
If you need to make changes, click the **Back to ID check requirements** to edit options. But if you're happy with the settings click **Send check**.

And that's it! You've sent an ID check using Real ID. You'll be redirected to the ID check details page and the customer will be sent their unique ID check link either by email and/or SMS.
---
// File: shopify/admin-extensions
# View IDs in the Shopify Dashboard
Save time by displaying ID checks directly in Shopify customer pages, avoiding the need to switch between Shopify and Real ID.
Real ID offers a customer **App Block** available on your Shopify customer pages. This block displays photos provided by the customer during their ID check, along with extracted fields and confidence scores.

This app block allows you to view ID check results without leaving the Shopify customer details page. It displays images of the government-issued ID, selfie, eSignature, and/or Proof of Address document. Additionally, it shows key metrics like face match confidence scores.
## Adding ID Verification to the Customer Details Page
1. Open a Shopify customer page by selecting **Customers** from the menu on the left and choosing a recent customer.
2. Scroll to the bottom of the page, click **+ App Block**, and select **ID check**:

3. A preview of the customer's ID check will appear. Click the pin icon in the upper right corner of the app block to pin it for all staff.

That's it! You've added the ID check to the customer details page.
## Frequently Asked Questions
### What actions can I take with this app block?
You can send reminders, initiate new ID checks, and manually approve or reject checks, just as you would in the full-screen version of the app.
### Can staff without permission view ID checks?
No, staff without access will see a permission denied warning.
### Can I quickly view the full screen ID check for a customer?
Yes, clicking on any image in the app block will open the full-screen version of the ID check.
### Can I view ID checks directly in orders too?
Yes, this same functionality is available for Orders in addition to Customers. Simply open an order in Shopify, and add the **ID Check** app block.
---
// File: shopify/billing
# Billing & Subscription
Real ID for Shopify uses Shopify's native app billing system. This means your Real ID subscription is managed directly through your Shopify account and appears on your regular Shopify invoice.
## How Shopify Billing Works
When you subscribe to Real ID, the charges are:
- **Billed through Shopify** — Real ID charges appear on your Shopify invoice alongside your other Shopify fees
- **Usage-based pricing** — You're charged based on the number of ID checks processed
- **No monthly minimums** — You only pay for what you use
For current pricing details, visit our [pricing page](https://getverdict.com/pricing).
## Viewing Your Current Plan
To view your current Real ID subscription:
1. Open the **Real ID** app in your Shopify admin
2. Click **Settings** in the navigation
3. Your current plan and usage information will be displayed
You can also view Real ID charges in your Shopify billing:
1. Go to **Settings** → **Billing** in your Shopify admin
2. Click **View all charges** or check your recent invoices
3. Real ID charges will appear as app charges
## Changing Your Plan
To upgrade or change your Real ID plan:
1. Open the **Real ID** app in your Shopify admin
2. Navigate to the plans or pricing section
3. Select your desired plan
4. Approve the subscription change when prompted by Shopify
Plan changes take effect immediately. If you upgrade mid-billing cycle, charges are prorated.
## Canceling Your Subscription
To cancel your Real ID subscription, you need to uninstall the app from your Shopify store:
1. Go to **Settings** → **Apps and sales channels** in your Shopify admin
2. Find **Real ID** in your list of installed apps
3. Click on **Real ID** to open the app details
4. Click **Uninstall** and confirm when prompted
:::warning Before You Uninstall
Make sure to download any ID check photos or data you need before uninstalling. See [Downloading Customer Photos](../for-merchants/downloading-customer-photos.md) for instructions.
:::
### What Happens After Cancellation
When you uninstall Real ID:
- **Billing stops immediately** — You won't be charged for any new ID checks
- **Final invoice** — Any outstanding usage charges will appear on your next Shopify invoice
- **Data retention** — Your ID check data will be retained for 90 days, then permanently deleted
- **Tags remain** — Any tags added to orders and customers will remain unless you remove them manually
### Reinstalling After Cancellation
If you reinstall Real ID within 90 days of uninstalling:
- Your previous settings and configuration will be restored
- Historical ID check data will still be available
After 90 days, all data is permanently deleted and you'll start fresh with a new installation.
## Frequently Asked Questions
### Why don't I see a billing tab in the Real ID app?
Real ID billing is handled entirely through Shopify's billing system. There's no separate billing section in the app because all charges appear on your Shopify invoice.
### Can I get a refund for unused ID checks?
Since Real ID uses usage-based billing, you only pay for ID checks that are actually processed. There are no prepaid credits to refund.
### How do I update my payment method?
Your Real ID subscription is charged to the payment method on file with Shopify. To update it:
1. Go to **Settings** → **Billing** in your Shopify admin
2. Update your payment method there
### Will uninstalling the app affect my orders?
Uninstalling Real ID will not modify, cancel, or refund any of your orders. The only changes are:
- ID verification will stop for new orders
- Real ID tags will remain on existing orders (you can remove them manually)
- Order notes added by Real ID will remain
### Can I pause my subscription instead of canceling?
No, pausing subscriptions is not supported. Shopify manages app billing, and subscription charges will continue to accrue as long as the app is installed.
If you need to stop being charged, you must uninstall the app (see [Canceling Your Subscription](#canceling-your-subscription) above). You can reinstall later if needed — your data will be preserved for 90 days.
---
// File: shopify/bulk-create-id-checks
# Create ID checks in bulk in Shopify
Real ID can be configured to automatically verify IDs before, during or after checkout. However, you may need to back fill older orders where customers haven't verified their IDs yet.
In this case, you can send ID verification links in bulk to your customers from the **orders** page in your Shopify dashboard.
This method allows you to send up to 50 ID checks at a time.
:::warning Limited to 60 days order history
Please note, by default Real ID is only granted access to read the last _60 days_ of order history on your Shopify store.
If you select one or more orders that are older than 60 days, Real ID won't be able to read the required details like the customers name, email address and more.
If you need to send ID checks to orders that are older than 60 days, [please contact us for help.](https://real-id.getverdict.com/contact)
:::
## Getting started
First, open your Shopify dashboard and open the **Orders** page. Here you can select one or more orders using the checkboxes on the left hand side.
Once you have selected the orders you would like to send ID checks for, open the three dot menu (**...**) on the top of the orders and select **Send ID check**.
:::info Select all orders shortcut
You can also select all orders on the current page by checking the box in the top portion of the menu.
This is also compatible with Shopify Order Views to help pre-filter orders based on the customer's ID verification status.
:::

Then you'll see a pop-up that confirms you'd like to send these ID checks. Finally, click **Send** to send these customers ID verification links.

By default, Real ID will send a new ID verification link to any order that already has one. If you don't wish to send a new ID verification link, uncheck the **allow duplicate checks for orders** checkbox.
## Frequently Asked Questions
### Will this use my custom settings I set up in the app?
Yes, these ID verification emails and links will use your pre-exisiting settings such as your content, theme, using your own email address to send these ID verification links.
This will include the rules such as live selfie capture, cross checking order details, and custom confidence thresholds.
### Will these ID verification emails be sent instantly?
As instantly as possible yes, all of these ID verfication emails will be delivered, and the ID verification results will appear in your Real ID app dashboard.
### Will this trigger the Real ID Shopify Flow Trigger `ID verification required for an order`?
Yes, every one of these ID verification links will also trigger any Shopify Flow workflows that have the `ID verification required for an order` as the trigger for that workflow.
### Will this send a new ID verification link if one is already created for the order?
By default yes, but unchecking the box to
### Will already verified customers be sent an ID verification link?
Yes, already verified customers will still be sent an ID verification link if they weren't already sent one **for that specific order**, regardless if they have verified in the past.
:::info Example scenario
Customer `amy@gmail.com` ordered a few months ago, and they verified their ID on your Shopify store with their order `#1001`.
This customer returns and places another order `#1002`, they aren't required to verify their ID again because they are remembered.
However, if the `#1002` order is selected and sent an ID check manually it will be delivered, since an ID check doesn't exist for this specific order.
:::
We highly recommend setting up a orders view in Shopify. That way you can filter out already verified customers if you would prefer not to send ID verification links to already verified customers.
---
// File: shopify/customer-segments
# ID Verified Customer Segments
With Shopify's powerful Customer Segments feature, you can create reports on your verified customer base.
Once this customer segment is set up, you can get the latest metrics like:
- Total number of verified customers
- Total spend of all verified customers
- Total order volume from verified customers
## How to create a Verified Customers segment
First, you'll need to open the **Segments** section under your **Customers** in your Shopify dashboard:

Then, click the **New Segment** button in the top right to start with a new segment:

Now you should see an empty new segment. Click the **filter** link in order to start designing this segment:

A new panel should appear on the right hand side of your screen, here you can create filters to specify which types of customers should be included in this new segment.
In this case, we can use [Real ID's real time tags](./tags.md) on customer profiles in order filter customers based on their verification status:

The query in the center of the page should now show _conditions_ to filter based on. Select the `CONTAINS` condition, so we can include customers into this segment based on their ID verification status:

Now you can select an individual tag. If you want to build this report based on verified customers, then select the `ID verification completed` tag:

:::tip Other segments are possible
You can also create other segments based off of customers that are still pending verification or have failed verification by changing the [tag](./tags.md).
:::
Now you have a customer segment that is all _automatically_ verified customers. You can include _manually approved_ customers by adding an `OR` condition to the segment and including the `ID check manually approved` tag:

After adding both for manually approved and automatically approved customers, your customer segment query should look like this:

Now you're ready to run the query. Shopify will automatically filter out unverified customers and only keep verified ones in the end segment:

:::note Metafields supported as well
Real ID also updates customer metafields in real time during verification as well. If you prefer you can use [metafields](./metafields.md) instead, which aren't as likely to be edited by staff directly from the orders page.
:::
## Exporting a report for this segment
After the segment is designed and you've run the report, you can export the results to a CSV or Excel spreadsheet for review.
In the top right, click the **More actions** dropdown, and in the pop up make sure your report only includes the results from the query:

In this pop up, you can also choose to export a CSV or an Excel file, the CSV is the default.
Shopify will email the report to you directly. Within the report will contain a row for each customer, and will include their total number of orders as well as their total account spend.
You can use functions in your spreadsheet editor like `SUM` to compute the total over value of all verified customers.
---
// File: shopify/filtering-orders-by-status
# Filtering orders by ID verification status in Shopify
To save time on find orders that have ID checks in progress or completed, you can quickly set up saved filters in your Shopify Orders dashboard.
After saving the filter, you'll be able to reuse them to quickly view ID checks that are outstanding or have completed and are ready for fulfillment.
## Filtering for orders that require ID verification
If you're using [ID checks only on specific risky orders after checkout](../triggers/high-risk.md), it might be helpful to set up a filter to only show orders that have an ID check sent.
---
// File: shopify/flow
# Shopify Flow
Real ID integrates with Shopify Flow to empower you to create flexible and robust automations to create ID checks based on order criteria and more.
First, [install Shopify Flow](https://apps.shopify.com/flow?referrer=real-id) onto your Shopify store to access these ID verification actions and triggers.
Shopify Flow is free to install and use and is available on all Shopify plans.
:::info Requires the Protect Plan
The Real ID Shopify Flow Triggers & Actions require a Protect Plan subscription to function properly.
Please make sure you have an active Protect subscription before building, testing or enabling your Shopify Flow workflow.
:::
## Creating ID checks for specific types of orders
You can use the *Create an ID check for an order* action within Shopify Flow to create an ID check for specific types of orders outside of the available pre-built triggers in the app's settings.
You can use this Shopify Flow action to create ID checks for specific scenarios such as:
* Orders over a specific amount, but also triggering Shopify high or medium risk thresholds
* Orders that do not have a matching billing & shipping address _and_ have high risk
* Orders with specific tags that should trigger ID verification
* And much more
First, open the Shopify Flow app in your store, then create a new Workflow from the button in the top right of the app:

### Create the trigger
First you'll need to design the trigger for your workflow. In this example, we'll use the **Shopify Admin API > Order created** trigger. You can find this trigger by searching for `order created` in the search bar on the right:
!(Select the Shopify Admin API's Order created event as the trigger for the new workflow by searching for "order created" in the search box in the Shopify Flow designer)[https://res.cloudinary.com/tinyhouse/image/upload/v1709155861/Real%20ID/Docs/CleanShot_2024-02-28_at_16.30.46.png]
### Decide which orders qualify for ID checks
Now that your trigger has been defined, we can define which orders should qualify for an ID check.
Click the blue plus button (+) on the trigger and select *Condition*:

This will add a new *Condition* to your workflow which will filter out orders based on the rules you set.
After creating the new *Condition*, you can design which orders should require and ID check by adding _criteria_ on the right hand side toolbar:

For example, let's say we want to send an ID check to all orders that have mismatching billing and shipping addresses *and* have a total order value over $100.
First we'll select the **Order** and then select the **billingAddressMatchesShippingAddress** attribute:

Now we can choose the value should be *False*, since we only want to create ID checks when the addresses do _not_ match:

Next, we can add the order amount threshold. Click *Add criteria* then search for the *currentTotalPriceSet* attribute. Then select the *shopMoney* option, so the total order value is in your own currency. Then finally click *amount* to select the actual amount of the order as a number.
Now we can design the criteria to use a *Greater then or equal to* 100.00 to instruct Shopify to only consider orders that are $100.00 and greater:

### Adding multiple conditions
You can use conditions to decide if one or multiple criteria need to be met for the flow to continue, but if that's not advanced enough, you can stack multiple conditions on top of each other.
For example, you can start the workflow with a condition that the source of the order should _not_ be from the Point of Sale sales channel (pos), then you can add another condition where the order needs meet certain risk thresholds.
### Creating the ID check for an order
After you have designed the conditions for which orders should qualify for an ID check, at the very last condition in the flow, click the plus icon (+) and select **Action**.
Then in the action panel, select the **Real ID** app:

Then select the **Create an ID check for an order** action:

### Customizing the ID check
You can customize the ID check content using the content and theme settings in Real ID, but you can also customize the messaging per flow using the **Create an ID check for an order** action.
After adding the action to your workflow, use the *Introduction* field to enter in a custom message if you'd like.

[Shortcodes are available to reference the customers name and order number](../theming/customize-content.md#shortcodes).
If this field is left blank, your default message will be used from [your content settings within the app](../theming/customize-content.md#customizing-emails).
### Turning the workflow on
When you're happy with the design of your flow, simply click **Turn on workflow** in the top right to enable the Shopify Flow.

That's it! You're custom Shopify ID verification flow is now live.
## Triggering workflows based on ID verification results
Real ID will automatically update your order and customers tags as well as metafields when a customer verifies their ID.
However, you may want to automate different actions based on the verification outcome, such as releasing verified orders for fulfillment, flagging orders that require manual review, or handling failed verifications.
Real ID provides four Shopify Flow triggers to handle all verification scenarios:
- **Order ID verified** - Triggers when online ID verification is successful
- **Order ID in review** - Triggers when verification requires manual review
- **Order ID failed** - Triggers when verification fails
- **POS ID scanned** - Triggers when an ID is successfully scanned at Point of Sale
### Order ID verified trigger
With the *Real ID - Order ID verified* trigger in Shopify Flow, you can release orders for fulfillment automatically, even if you have a 3PL.
### Setting up the trigger
First, open the Shopify Flow app, then click *Create a new Workflow* to start with a new workflow.
Then in the trigger selection menu, select the **Real ID** app:

Then select the *Order ID verified* trigger:

Now this workflow will automatically trigger when a customer verifies their ID. This will also trigger [when a staff member manually approves the ID](../for-merchants/overridding-results.md#manually-approving-an-id-check).
This trigger returns the corresponding *Order* from the ID check. So then you can loop over the `orderFulfillments` of the order and perform the *Release order hold* Shopify Admin action on each order fulfillment.
:::info
If the ID check is created manually _without_ an association with the order, then this trigger will not fire when the customer verifies their ID.
Also, if you're using the [after registration flow](../flows/after-registration.md), this will also not trigger because the ID check is only associated with their Shopify customer profile.
:::
### Order ID in review trigger
Use the *Real ID - Order ID in review* trigger to automate actions when an ID check requires manual staff review. This trigger fires when:
- Age verification fails (customer is underage)
- Cross-checking fails (name or address doesn't match order details)
- Document is on the fraud blacklist
- AI verification is inconclusive
This trigger provides additional context including the reason for review, allowing you to create targeted workflows such as:
- Automatically notifying specific staff members based on the review reason
- Flagging orders with high-risk indicators for additional scrutiny
- Creating different approval workflows for different failure types
#### Available trigger data
- **Order** - The Shopify order reference
- **Manually set to review** - Boolean indicating if staff manually set the check for review
- **Check ID** - Unique identifier for the ID verification
- **Review reason** - The specific reason requiring manual review (e.g., "Age verification failed", "Cross-check validation failed")
### Order ID failed trigger
Use the *Real ID - Order ID failed* trigger to handle completely failed verifications, including both automatic failures and manual staff rejections. This trigger fires when:
- Verification fails after processing (completed but unsuccessful)
- Staff manually rejects an ID check
- Document verification fails multiple validation steps
This allows you to automate responses such as:
- Automatically canceling or refunding failed orders
- Sending custom communication to customers about next steps
- Escalating to fraud prevention teams for high-risk failures
- Creating exception workflows for specific failure types
#### Available trigger data
- **Order** - The Shopify order reference
- **Manually rejected** - Boolean indicating if staff manually rejected the check
- **Check ID** - Unique identifier for the ID verification
- **Failure reason** - The primary reason for failure (e.g., "Cross-check validation failed", "Document expired")
- **Error details** - Additional technical information about the failure
### POS ID scanned trigger
Use the *Real ID - POS ID scanned* trigger to automate workflows when a driver's license is successfully scanned at your Point of Sale and associated with an order. This trigger fires immediately after the scan is processed and linked to an order.
#### When this trigger fires
The POS ID scanned trigger fires when:
- A staff member scans a driver's license at a POS terminal
- The barcode is successfully parsed
- Age verification passes (customer is of legal age)
- Document is not expired
- The scan is associated with a Shopify order
#### Available trigger data
- **Order** - The Shopify order reference
- **Customer** - The Shopify customer reference (provides direct access to customer data)
- **Scan ID** - Unique identifier for the POS scan
- **Location ID** - The POS location where the scan occurred
- **Staff ID** - The staff member who performed the scan
#### Use cases
This trigger enables powerful POS-specific workflows:
**Automatic Fulfillment**
Release orders for fulfillment immediately when ID is scanned in-store, eliminating manual verification steps for in-person purchases.
**Reorder Optimization**
Skip online ID verification for customers who have completed POS scans in the past. Use the "Get POS Scan" Flow action to check if a customer has a scan on file before requiring online verification.
**Compliance Tracking**
Automatically log and track age-restricted product sales by location and staff member for compliance reporting and auditing.
**Staff Performance**
Monitor which locations and staff members are consistently performing ID checks for age-restricted products.
#### Example workflow
Here's a practical workflow that reduces friction for returning customers:
1. **Trigger**: Order created (online)
2. **Condition**: Order contains age-restricted products
3. **Action**: Get POS scan details (using customer reference from the order)
4. **Condition**: Check if POS scan exists
- **If scan exists**: Order already verified in-person
- **Action**: Add "Verified (POS)" tag to order
- **Action**: Release order hold automatically
- **If no scan**: Customer needs online verification
- **Action**: Create ID check for order
- **Action**: Send verification email to customer
This workflow allows customers who have verified their ID in-store to place online orders without redundant verification, improving the customer experience while maintaining compliance.
#### Important notes
:::info Prerequisites
- The scan must be successfully associated with an order through the POS workflow
- Only "passed" scans trigger the workflow (age verified and document not expired)
- Shop must have Shopify Flow permission enabled
:::
:::tip Pro Tip
Combine this trigger with the "Get POS Scan" action to create intelligent verification workflows that remember customers across channels (online and in-store).
:::
## Triggering a workflow when a customer is ID verified
This is coming soon. Unlike the *Order ID verified* trigger, this will fire when the _customer_ verifies their ID.
This will be compatible with the [after registration flow](../flows/after-registration.md). Or if you send the ID check manually, but only select the customer's profile instead of the specific order.
## Questions about setting up your flow?
If you have any questions about setting up your Shopify Flow workflow, [please contact us](https://getverdict.com/contact) with which types of orders you'd like to verify and we'd be happy to help you get started.
---
// File: shopify/metafields
# Metafields
In addition to syncing the ID verification status to the tags on the order and customer profile - Real ID also syncs metafields to the order and customer profiles on your Shopify store.
For example when an order requires ID verification, then Real ID will update the `real_id.step` to `in_progress` on the order. Then when the customer completes ID verification, the `real_id.step` metafield will be updated to `completed`.
You can use these metafields within your store's theme to conditionally show or hide elements based on the customer's verification status, or alter the customer experience entirely.
## `real_id.verified` Metafield
This metafield is present on both the customer and order. It is a boolean type that will only be `true` if the ID check was passed or it was manually approved.
For example, you could use it to tell if the currently logged in customer is verified within a liquid template:
```liquid
{% if customer.metafields.real_id.verified %}
You're verified! ✅
{% else %}
You're not verified ❌
{% endif %}
```
## `real_id.step` Metafield
This metafield is present on both the customer and the order. It is a short text field that can be one of three values:
- `in_progress` - an ID check has not been completed yet
- `completed` - the ID check has passed or been manually approved
- `failed` - the ID check has failed or was manually rejected
Here's an example of displaying the customer's current ID verification status within a liquid template:
```liquid
{% if customer %}
{% case customer.metafields.real_id.step %}
{% when 'in_progress' %} Please complete your ID check to continue
{% when 'failed' %} We were unable to verify your ID
{% when 'completed' %} You have passed ID verification
{% endcase %}
{% endif %}
```
:::note
This metafield will only be present on orders or customers that require ID verification.
If you have rules set up that only require ID verification on specific conditions, then these metafields will not be present on those orders.
:::
## `real_id.check_id` Metafield
This metafield is present on both the customer and the order. It is a short text field that contains the unique token that references the customer's most recent ID check.
Manually creating new ID checks will _overwrite_ the `real_id.check_id` metafield. Please be careful when creating ID checks manually, if the customer is already verified then a new ID check will replace the current `real_id.check_id` metafield.
You can use this token as the ID parameter for [retreiving the details of the ID check with the Real ID REST API](../api/checks.mdx).
:::note
This metafield will only be present on orders or customers that require ID verification.
If you have rules set up that only require ID verification on specific conditions, then these metafields will not be present on those orders.
:::
## Liquid Examples
Here are some examples to help with common uses of metafields.
### Displaying a blur on images if the customer isn't logged in and verified
You can add a blur to all images on your site if the customer isn't logged in and verified using a condition on the `real_id.verified` metafield:
```liquid
// styles.css.liquid
{% unless customer.metafields.real_id.verified %}
img {
filter: blur(1.5rem);
}
{% endunless %}
```
:::tip
You will need to use a `.css.liquid` or `.scss.liquid` file for this functionality. A normal CSS file will not be able to detect the currently logged in customer's metafields.
:::
### Display a call to action to verify if the customer isn't verified yet
You can conditionally show a call to action to login and verify if the customer isn't verified yet.
```
{% unless customer.metafields.real_id.verified %}
Verified account required
To continue with checkout, please login and verify your ID.
This process is instant and only needs to be done once.
{% endunless %}
```
### Creating a custom ID check prompt
For the most control, you can use our JS SDK to render an ID check prompt on any page and ID gate submission buttons or any elements in liquid.
Real ID will automatically load the current customer's ID check, but if you prefer to pass one created from the [REST API](../api/checks.mdx), you can do so. [Follow our example here.](../js.mdx#loading-in-a-specific-check)
## Accessing Metafields with GraphQL
In addition to accessing ID verification metafields via the Liquid within your store's theme, you can access these fields through the Shopify Admin GraphQL.
### Customer ID verification metafields
Here's an example query to retrieve the current ID verification related metafields with a GraphQL query:
```gql
query getCustomerDetails($customerId: ID!) {
customer(id: $customerId) {
firstName
lastName
email
phone
id
tags
metafields(first: 5, namespace: "real_id") {
nodes {
key
value
updatedAt
}
}
}
}
```
### Order ID verification metafields
Here's an example query to retrieve the current ID verification related metafields with a GraphQL query:
```gql
query getOrderDetails($orderId: ID!) {
order(id: $orderId) {
id
tags
metafields(first: 5, namespace: "real_id") {
nodes {
key
value
updatedAt
}
}
}
}
```
## ID verification before before checkout
If your store is requiring ID verification **before checkout** or **before viewing store**, then the metafields on the customer will be applied _after_ they register or after they place an order and Shopify creates their customer profile.
:::tip
To use the ID verification metafields on your store's theme, we highly recommend you prompt customers to login. Without the customer logging in, your theme won't be able to access the customer's current ID verifications status through metafields.
:::
---
// File: shopify/migrating-to-app-blocks
import TOCInline from "@theme/TOCInline";
# Migrating after checkout ID verification to app blocks
:::info Shopify after checkout only
This applies to Shopify merchants using Real ID for after checkout ID verification.
If you're using before checkout, or after customer registration ID verification flows, there's no action required.
:::
Shopify apps integrating with your Order status page need to be added as app blocks to your Thank you and Order status pages. On **August 26, 2026**, Shopify will automatically upgrade all remaining stores to the new pages — after that, the legacy ID verification prompt no longer appears on your order status page.
It's a simple transition, and Real ID's app blocks have been selected by [Shopify as an exclusive ID verification launch partner](https://www.shopify.com/blog/introducing-customer-account-extensions#data). This guide will show you how to switch.
## How do I know if I need to switch to app blocks?
There are two parts to switching to the new upgraded order status page: upgrading your Shopify checkout itself, then updating Real ID to use the app blocks.
### In Shopify
Open your store's checkout settings, if you see a prompt to upgrade to the new Thank you and Order status pages, then that means you're using the legacy order status page. Here's an example of a store that still needs to upgrade their order status page:

### In Real ID
In the Real ID settings page, if you see the _Legacy_ badge next to the _After Checkout_ box, this means your store is currently using the older version of the order status page integration:

If you don't see this _Legacy_ badge, it means you're using the app blocks version of Real ID's order status integration instead and no action is required.
## What happens if I don't switch to app blocks?
On **August 26, 2026**, Shopify will automatically upgrade your store to the new Thank you and Order status pages, and the legacy integration will stop working.
After the upgrade, Real ID won't be able to display the ID verification prompt in your order status page. The app will still send ID checks to your customers by email and SMS, and they'll still be able to verify their IDs through those links. But without the on-page prompt, fewer customers finish verification right after checkout — we highly recommend adding the app blocks before the deadline.
## How do I switch to app blocks?
This transition is simple, and your existing ID verification triggers as well as your already verified customer base will automatically carry over to your new order status and thank you pages.
Here's how to upgrade your Order Status and Thank you pages and keep ID verification embedded in them:
1. Open your [Checkout settings in Shopify](https://admin.shopify.com/settings/checkout)
2. Click the **Customize** button under the **Configurations** section at the top of the page:

3. In the editor, open the **Thank you** and **Order status** pages and add the ID verification app block:

This short video shows you how to add the ID verification app block to a page with the Shopify theme editor:
4. Click the sections icon to open the Sections sidebar, and then click _Publish_ to finish the upgrade.

That's it, you're now using Shopify's newest order status and thank you pages in your store.
## What's the Thank you page?
In the past, after a customer placed an order they would be shown the order status page immediately. As part of this new upgrade, Shopify is introducing a new thank you page that is shown first.
The Thank you page shows the customer a confirmation number, but not the true order number. If the customer refreshes the page, or opens the order confirmation link sent to their email, then they'll be shown the Order status page.
The Thank you page is a short lived transitory page that's only shown once. After that, the customer is shown the order status page.
We recommend placing the ID verification block on both of the thank you and order status pages, so that way if customers return to see their order's status, they'll also see the ID verification block as well if they haven't finished verification yet.
---
// File: shopify/notes
# Notes
By default Real ID leaves notes on the order during the ID check lifecycle.
These notes are left on the timeline of the order within the Shopify order's details:

Notes will be automatically added to the order timeline during the ID verification flow:
* `Delivered an ID check to the customer`
* `Customer opened the ID check`
* `Customer uploaded their ID photo`
* `Customer uploaded their headshot photo`
* `Customer completed ID verification`
* `Customer failed ID verification`
## Disabling notes
This feature can be disabled or reenabled at any time.
First open the **Notifications** section under the **Settings** page in the app, and then open **For your Team**:

These settings control the notifications that are sent to your team.
Within this tab, you can disable or enable the feature by clicking the toggle, then clicking **Save**.

:::info
The notes left by Real ID do not directly affect the order payment or fulfillment status in any way.
The notes are only for display purposes, so you can see the latest ID check events timeline without leaving the order in the Shopify dashboard.
:::
---
// File: shopify/opening-id-checks
# Opening ID checks from the Shopify dashboard
You can easily open the corresponding ID check from your orders on Shopify, without searching for it within the Real ID app.
:::tip ID checks in your Shopify Dashboard
Save time and clicks by viewing ID checks without leaving the Shopify dashboard by [adding the ID check app block](./admin-extensions.md).
:::
## Opening the ID check from an order
With the order opened in your Shopify dashboard, click the **More actions** dropdown. Then click on the **View ID check** option.

This will open the corresponding ID check for that order, if there is one.
## Opening the ID check from the customer
With the customer profile opened in your Shopify dashboard, click the **More actions** dropdown. Then click on the **View ID check** option.

## Frequently Asked Questions
### If there are multiple ID checks for one order or customer, which one will Real ID open?
Real ID will always prefer the newest ID check sent to the customer or order.
For example, if the customer fails their first ID check and they are sent another to try again, then the latest ID check will be shown.
### The system can't find the customer's ID check
Real ID is currently limited to viewing 60 days history of your order data.
If the order was placed more than 60 days ago, this feature may not be able to find the association.
You can search for the order within the home page of the app instead.
---
// File: shopify/pos/dual-barcode
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
# Dual-Barcode Driver's Licenses
:::warning Known Limitation
Some US driver's licenses feature two barcodes. The Shopify POS scanner may
accidentally capture the smaller barcode instead of the main barcode that
contains customer information.
:::
## The Problem
Some US states issue driver's licenses with multiple barcodes on the back:
- A **large 2D barcode** (PDF417) containing the customer's information
- A **smaller barcode** used for other purposes
The Shopify POS barcode scanner can accidentally scan the smaller barcode,
resulting in incomplete or incorrect data capture.
## Affected States
This issue has been observed with licenses from:
- Nevada
- Florida
- Texas
- Other states may also have dual-barcode licenses
## Which Barcode to Scan
Always scan the **larger barcode** on the license. See the examples below:



## Instructions for Staff
1. When scanning a customer's driver's license, locate the **larger barcode**
2. Position the scanner to capture only the large barcode
3. If the scan fails or returns incomplete data, check if the smaller barcode was accidentally scanned
4. Close the scanning window and try again, focusing on the larger barcode
:::info Coming Soon
Shopify has recently released a new camera-based scanning system that we are
working on integrating. This will allow Real ID to automatically focus on the
correct barcode, eliminating this issue.
:::
---
// File: shopify/pos/printing-scan-id-on-receipt
# Print the Scan ID on POS Receipts
When you scan a customer's driver's license at the Shopify POS, Real ID
attaches the **scan ID** to the order. You can update your printed receipt
template to display this scan ID, so a record of the verification prints
on every receipt for a scanned sale.
This is useful for:
- Compliance and audit records
- Giving customers a reference if they ever need to dispute a verification
The receipt will read:
> Customer's ID scanned by Real ID. Scan ID: bKxg4YvNfM3
## Before you start
:::warning Add products to the cart before scanning
For the scan ID to print on the receipt, at least one product must be in
the cart **before** you scan the customer's ID.
Real ID attaches the scan ID to the first line item at the moment of
scanning. An empty cart means there's no line item to attach to, and the
receipt won't have anything to display.
If you open the **Scan Drivers License** tile with an empty cart, Real ID
will prompt you to add items first.
:::
## Open the POS receipt code editor
The receipt template lives under **Settings → Receipts → Receipt code
editor** in your Shopify admin.
For a walkthrough, watch this short screencast: [How to open the POS
receipt code editor](https://cleanshot.com/share/CSBZK8mH).
## Add the receipt code
Paste this snippet into the **Printed receipt** template, in the spot
where you want the scan ID to appear — typically near the bottom, after
totals and payment information:
```liquid
{% assign scan_id = '' %}
{% for li in order.line_items %}
{% for p in li.custom_attributes %}
{% if p.first == 'real_id_scan_id' %}
{% assign scan_id = p.last %}
{% endif %}
{% endfor %}
{% endfor %}
{% if scan_id.size > 0 %}
Customer's ID scanned by Real ID. Scan ID: {{ scan_id }}
{% endif %}
```
The `if scan_id.size > 0` check makes sure the line only prints when an
ID was actually scanned for that sale. Non-scanned sales print the
receipt without it, so you can add this snippet to your default template
without affecting other orders.
Save the template, then use the **Preview** feature to test against an
order that had an ID scanned. You should see the line render at the
bottom of the preview.
## Optional: debug snippet
If the line doesn't appear when you expect it to, drop this debug block
into your receipt template and preview a receipt. It dumps everything the
template can read about each line item's custom attributes, which helps
you confirm whether the scan ID was actually attached.
```liquid
```
For a scanned order, you should see something like:
```
--- order.line_items[0] ---
name =
custom_attributes.size = 1
ca[0] first=real_id_scan_id | last=
```
If `custom_attributes.size = 0`, the scan ID wasn't attached to that line
item. The most common reason is an empty cart at scan time — see the
warning above.
Remove the debug block once you've confirmed the production snippet works.
## FAQs
### Why doesn't an older order show the scan ID?
POS orders placed after **May 30, 2026** carry the scan ID on a line
item, which is what the receipt template reads from. Orders placed before
that date don't have the scan ID in a place the receipt template can
access, so the line won't render — even if the customer's ID was scanned
at the time.
Re-printing a receipt for an older order won't display the scan ID. New
orders going forward will work as expected.
### Does this print on every receipt?
Only for sales where an ID was scanned through the Real ID POS tile.
Receipts for unscanned sales print normally without the extra line, so
it's safe to leave the snippet in your default template.
### Can I customize the wording?
Yes. Change the text inside the `
...
` tag to anything you'd like.
The `{{ scan_id }}` variable is the value that prints, so you can wrap it
in any wording your receipt design needs.
### What if I forget to add items to the cart before scanning?
The scan still verifies the customer's ID, but the receipt for that sale
won't display the scan ID. You can look up the scan in your Real ID
dashboard or in the order's note attributes from Shopify admin.
If you need help setting this up, [contact us](/contact).
---
// File: shopify/pos/upgrading
# Upgrading the Real ID POS App
When a new version of the Real ID POS extension is released, you may need to update the tile on your Shopify POS device to get the latest features and bug fixes.
## How to upgrade
### Step 1: Open the network menu
1. Open Shopify POS on your device
2. Tap the **Network** icon on the bottom left of the screen
### Step 2: Refresh store data
1. Tap **Store data**
2. Tap **Refresh all** to retrieve the latest version of all Shopify apps connected to your POS
The refresh may take some time, but it will indicate when it's finished.
## When to upgrade
You should upgrade the POS tile when:
- You've been notified of a new Real ID release
- You're experiencing issues with the POS scanner
- New features have been announced that you'd like to use
:::tip
If you're still seeing old behavior after following these steps, try force-quitting the Shopify POS app completely and reopening it.
:::
---
// File: shopify/pos
# Real ID Shopify POS Integration
We offer two different ID verification options for Shopify POS.
- [ID photo verification](#id-photo-verification) - captures the details of the ID document and stores the images
- [ID barcode scanning](#id-barcode-scanning) - uses your Shopify POS barcode scanner to read the details of the U.S. drivers license from the barcode.
## ID barcode scanning
U.S. state issued driver's licenses feature a barcode on the back which stores the key information about the license holder.
Real ID can read this barcode, extract these details and apply your [minimum age policy](../rules/age-verification.md) as well as check for expiration and validity of the license.
### Getting started
First, open your Shopify POS and add a new tile to your home screen:

Then select the **App** option:

Then select the **Real ID** app, and choose the select the _Scan a Drivers License_ tile:

Then at any time before, during or after checkout you can open this tile and scan the back of the customer's drivers license, and it will display the information extracted from the license and automatically check the customer's age and expiration of the ID.
### How to scan drivers licenses with the Shopify POS
Opening the **Scan as Drivers License** tile, you'll see a camera view pop up. Simply move the POS camera or barcode scanner to capture the barcode on the back of the drivers license to capture it.

Real ID will then automatically scan the ID's details and check your age restrictions and the expiration of the ID:

:::info Scanning multiple licenses
At this time if you need to scan multiple licenses per transaction, you'll need to close the tile and reopen it to start a new ID scan.
:::
### Automatic tagging and metafields
When you scan a customer's ID and it passes verification, Real ID can automatically:
- Tag the customer with `ID scanned (POS)`
- Tag the order with `ID scanned (POS)`
- Set metafields on both the customer and order
This helps you:
- Create automated workflows using Shopify Flow
- Track which customers have been ID-verified
- Segment customers based on verification status
#### Requirements for automatic tagging
For automatic tagging to work, you need:
1. **After Checkout flow enabled** - Go to your Real ID settings and turn on the After Checkout flow (no triggers needed)
2. **Customer attached to order** - The POS order must have a customer attached to it
3. **Successful ID scan** - The ID must pass age verification and not be expired
### Limitations
Here are the limitations of this ID scanning feature at this time:
- ID scanning only supports U.S. issued drivers licenses.
- It will not store the actual image of the license itself, it will only capture and store the data extracted from the barcode.
- ID scanned data will not display in the Real ID dashboard at this time (coming soon)
#### Dual-Barcode Driver's Licenses
Some US states (Nevada, Florida, Texas, and others) issue driver's licenses with two barcodes. The smaller barcode can be accidentally scanned instead of the main barcode that contains customer information. See our [guide on scanning dual-barcode licenses](./pos/dual-barcode.mdx) for detailed instructions.
#### Camera Scanner Reset Issue
If a barcode scan fails due to an incomplete or cut-off barcode, you'll need to close the scanning window and reopen it to try again. This is due to a limitation in Shopify's POS barcode scanner system where the scanner state cannot be reset after a failed scan.
When you encounter this issue:
1. Tap the "Close" button
2. Reopen the "Scan Drivers License" tile
3. Try scanning the barcode again
For more technical details about this limitation, see the [Shopify community discussion](https://community.shopify.dev/t/scanner-api-state-does-not-reset/976).
If you need to store the entire image of the ID, or verify non-US drivers license documents, consider using our [ID photo verification tile instead](#id-photo-verification).
## ID photo verification

Real ID offers an direct POS integration for Shopify merchants.
Within your Shopify POS, you can start a new ID check from a tile in your Shopify POS device. Then you can scan the customers ID in real time before or after checkout.
### How does it work
The Real ID **Create ID Check** POS tile will open a new browser window on your POS device, then you'll be able to scan the customer's ID and see the results in real time.
After scanning the customers ID, simply close the browser window and return to the POS to finish checkout.
Real ID will automatically read the first name, last name, date of birth and other details from the ID, and you'll be able to find the ID check from within the app's homepage.
:::tip
[Your age restrictions](../rules/age-verification.md) and other rules will apply to ID checks from the POS tile.
:::
### Sending an ID check from the POS tile
Add a **Link** tile to your Shopify POS to start an ID check in store with one tap. The tile opens the Real ID check page on your POS device, where you capture the customer's ID before, during, or after checkout.
#### Get your tile link
The easiest way is to copy the ready-made link from the app. In the Real ID admin, open **POS ID Verification** and copy the URL shown there — no typing required.
If you'd rather build the link yourself, it follows this pattern:
```
https://admin.shopify.com/store/STORE/apps/realid/shopify/checks/pos/create
```
Replace `STORE` with your store's myshopify subdomain — the part before `.myshopify.com`. For example, a store at `acme-supply.myshopify.com` uses:
```
https://admin.shopify.com/store/acme-supply/apps/realid/shopify/checks/pos/create
```
#### Add the tile
First, open your Shopify POS and tap **Add tile**:

1. Choose the **Link** tile type.
2. Paste your link into the tile's **URL** field.
3. Name the tile `Verify Customer's ID`.
4. Tap **Save** to create the tile, then **Save** on the grid to pin it.
That's it — tapping **Verify Customer's ID** starts a new ID check and opens the camera so you can capture the customer's ID.
:::note
If the tile opens the Real ID homepage instead of a new check, your Shopify POS session has expired. Close the Real ID app, then tap the tile again.
:::
Need another Real ID tile for your workflow? [Get in touch.](/contact)
### Limitations
#### Mobile devices and tablets only
At this time, the Real ID **Create ID Check** tile only supports mobile phones and tablets. The Shopify official POS systems do not offer direct camera support at this time. Real ID relies on access to the device's camera to scan the customer's ID.
#### Customer and order associations not supported
While Real ID automatically reads and assigns the first and last name of the customer from their ID, this integration does not associate with the Shopify customer account nor the order after checkout at this time.
This also means that the ID verification tags and metafields will also not update automatically for ID checks created from the POS integration.
---
// File: shopify/setting-up-an-order-view
# Setting up an ID verification view for your orders in Shopify
By default the main **Orders** page in Shopify shows the tags on the far right of the orders table.
This can make it difficult to easily see the ID verification status of your orders. But we can quickly create a custom view in Shopify in just a few clicks. Then you'll have a dedicated view to easily see outstanding, passed or failed ID checks at a glance.

## Creating a **ID checks** view
First, open your Shopify dashboard and open the **Orders** page:

At the top of the page, you should see a Plus icon. Clicking on it will create a new **View**:

This should open a pop up to name your new orders view. We recommend giving it a name like **ID checks**:

Then click **Create view** and you'll have a new view to customize separately from your other order views.
## Only including ID verified orders based on tags
Now that you have a separate view you can now apply a filter to this view to only show orders that are in a specific status.
Click on the filter icon in the main search bar:

Then and paste this into the search to only include automatically verified orders _and_ ID checks approved by your staff:
```
"ID verification completed" OR "ID check manually approved"
```
:::note Quotes required
The quotes (`"`) in the above example are required for this filter to work properly.
:::

Then click **Save** in the top right to save the filter so this view will only show ID verified orders.

## Modifying the columns order
Now you have a separate view that you can modify the placement of the **Tags** column, which is [how Real ID syncs ID verification statuses to your Shopify dashboard](./tags.md).
At the top of the page, click your new **ID checks** view to open a dropdown menu. Then click **Modify columns** to begin customizing the layout of this view:

Now you should see the columns of the **Orders** table are now editable. The **Tags** column by default should be on the far right side:

Simply drag and drop the **Tags** column further to the left so it's more prevalent on your screen:

You can also hide other columns by clicking the eye shaped icon on that column. When you're done making your changes to the **ID checks** view, click **Save** in the top right hand corner to save your changes:

That's it! Now you'll be able to quickly switch between the normal views like **Opened**, **Unfulfilled** and easily switch to **ID checks**.
---
// File: shopify/tags
# Tags
To keep you updated with the latest changes on ID verifications, Real ID synchronizes the ID check statuses of customers & orders in [Shopify with _tags_](https://help.shopify.com/en/manual/shopify-admin/productivity-tools/using-tags).
These tags are visible in your orders as well as on the customer profiles within the Shopify backend.

:::info Real ID won't affect other tags
Real ID will only change tags related to ID verification. Other tags on your orders and customers will _not_ by removed or overwritten by ID verification related tags.
:::
## How it works
```mermaid
flowchart TD
id_check_delivered([ID verification required]) -- Customer submits ID photos--> id_check_passed([ID verification completed])
id_check_delivered -- Customer fails ID check --> id_check_failed([ID verification failed])
id_check_failed -. Staff member overrides results .-> id_check_manually_approved([ID check manually approved])
id_check_passed -. Staff member overrides results .-> id_check_manually_rejected([ID check manually rejected])
```
When an order qualifies for an ID check through your automatic triggers, it will be tagged with `ID verification required`.
Then, when the customer passes ID verification, it will change to `ID verification completed`.
However, if the customer fails ID verification, the order & customer's profile will be changed to `ID verification failed`.
:::tip
These tags will apply to both the _customer_ and the _order_ within Shopify. The customer tags are used for remembering repeat customers so they only need to verify once.
:::
## Available Tags
Real ID uses the following tags to sync the ID check status:
- `ID verification required` - The order or customer requires ID verification
- `ID verification completed` - The customer passed the ID check
- `ID verification failed` - The customer submitted their photos required for the ID check, but the system was not able verify them
- `ID check manually approved` - A staff member manually approved the ID check
- `ID check manually rejected` - A staff member manually rejected the ID check
- `ID expired` - The ID was valid at the time of verification, but now it is now expired
## Custom tags
You can customize the names of the tags Real ID leaves on orders & customers during the ID verification process.
To customize these tags, open the **Settings** page, then open the **Notifications** area, and click the **For your Team** tab.

Then you can customize the tag to your choosing. In this example, the tags have been shortened to `ID passed` instead of `ID check completed`:

:::tip
Any changes to tags will **not** apply to past ID checks. It will only apply to new orders and customers after the changes are made.
:::
## Limitations on tags
Tags are a useful feature for viewing a customer & order's ID check status at a glance from the Shopify Dashboard.
However, Real ID cannot guarantee that tags are 1:1 exactly with the ID verification status of an order or customer because:
- Real ID tags can be altered by any other app
- Real ID tags can be altered via the Shopify dashboard by any staff with orders access
- Real ID tags can by altered by Shopify Flows, Zapier, Make, Mechanic or any other automation tool connected to your store
If it is critical for your business to hold orders based on ID verification, please consider our [Webhooks feature](../api/webhooks.mdx) for automating actions to your fulfillment system.
---
// File: theming/branding
# Branding ID checks
You can use your own brand within ID checks, and your brand will not only extend to the ID check flow but also to emails sent to customers.
Your theme settings for Real ID can be found within the **Appearance** section with the app **Settings**:

## Uploading your Logo
At the bottom of the **Branding** section, you'll be able to upload your own logo:

Here you can drag and drop your logo, or alternatively you can click on the dashed box to open a file browser to find and select a file.
:::note
Your logo will be automatically resized in order to make it responsive on mobile, tablet and desktop views. There's not need to resize the image before uploading.
:::
## Theming
You can design the Real ID theme to match your store's theme. Within the **Branding** settings, you can set the **Primary** and **Button** colors of the theme.
### Primary color
The **Primary color** is applied to the background of the ID checks, in both emails as well as the ID check flow.

:::tip
We recommend using a neutral color for the primary color, like a light gray. This helps make the **Start ID verification** button more visible to the customer.
:::
### Button color
The **Button color** is applied to the background of the call to action buttons to start the ID check, as well as buttons within the ID check flow.
:::tip
We recommend using a darker color for the button color. The font color of the button is white by default and a darker color will add more contrast to make the button more visible and readable.
:::
---
// File: theming/customize-content
# Customizing ID check content
You can customize the content within Real ID, including the content shown within the ID check flow as well as the emails sent to customers during the ID check lifecycle.
## Choosing the default language
Real ID allows customers to change the translation of the ID check prompts within the flow.
However you can set the initial default language within the **Appearance** section of the **Settings** page.
Real ID currently includes translations for the following languages:
* English
* Spanish
* German
* French
* Korean
If you need additional languages supported - [please contact us](mailto:support@getverdict.com).
## Customizing Emails
During the ID check lifecycle, Real ID will send email notifications to the customer at each step along the way.
* `Introduction` - the first email sent to the customer, explaining why they're being sent an ID check.
* `In Review` - sent if the customer's ID wasn't able to be automatically verified because of bad image quality, missing fields, an expired ID or any other failed reason.
* `Verified` - sent if the customer's ID was able to be automatically verified _or_ if their [ID check is manually approved by one of your staff](../for-merchants/overridding-results.md).
* `Failed` - only sent if the [ID check is manually rejected by your staff](../for-merchants/overridding-results.md) in the Real ID dashboard
The content of these email notifications are customizable in the **Appearance** area of the **Settings** page within the app:

Then you'll be able to choose between email templates options and edit the content:

As you type, you'll see a preview of the email within the **Preview** on the right side.
### Shortcodes
To personalize the message, use shortcodes to reference the customer's name and order number.
* `[orderId]` - The unique order ID number
* `[firstName]` - The customers first name
* `[lastName]` - The customers last name
:::tip
As a best practice, we recommend including the customer's name and order number within the message. This helps customers recognize that this ID check is related to their order.
:::
### Best practices
The **Introduction** email is the most important email template. It should clearly communicate:
* Why the customer needs to complete ID verification
* That ID verification is secure and convienent
* What happens when they finish their ID check
If you require ID verification as part of your K.Y.C. compliance needs, or for age verification purposes, then you should communicate that as well.
### Disabling customer emails
At this time you can optionally disable the **In Review** email. The **In Review** email is sent when the customer fails automatic ID verification, but has not been manually rejected or manually approved.
You can choose to disable this email if you'd like. If this option is enabled, then customers will _not_ receive an email if they fail ID verification.
## Customizing SMS messages
Due to phone carrier restrictions for content sent via SMS messages, the ID verification notice message is not editable.
However, the default includes the order number and customer name, as well as the unique ID check link that allows customers to complete ID verification. [Learn more about how Real ID sends SMS messages](./sms).
---
// File: theming/sms
# SMS messages
For ID checks sent after checkout automatically Real ID can also send an SMS message to the customer if their phone number is provided in the order.
The SMS message will include a unique link for the ID check, the same as the email sent to customers.
## SMS Content
Unfortunately due to restrictions placed by phone carriers, we cannot allow the customization of SMS messages.
## From phone number
All ID checks sent via SMS will come from a phone number managed by Real ID:
* `+1 (884) 997-2426`
If the customer's phone number is registered in a country that supports Alpha codes, they will receive an SMS message from `Real ID`.
### Activate the phone number checkout field on Shopify
To set up phone number collection from customers during checkout, open your Shopify **Settings** and then open the **Checkout** section:

Then scroll down to the **Customer information* section, and choose an option under the **Shipping address phone number** options:

You can require phone numbers or make them optional. If any order triggers an ID check and the customer provides their phone number for shipment, then Real ID will use this phone number to send the customer a link to their ID check.
## Frequently asked questions
### If I send an ID check manually, will an SMS message still be sent to the customer?
Yes, as long as the customer's phone number field is entered while creating the ID check.
### I'm seeing an error that the SMS message failed to send, why is that?
The most common reason why an SMS message fails to send is because the phone number on the order is not valid or belongs to a landline. In these scenarios it's not possible to send an SMS message to the customer.
### Are SMS messages an additional cost?
No, SMS messages are not any additional cost to the ID check fee.
---
// File: theming/white-label-domains
---
// File: theming/your-email-address
# Using your own email address
Build trust with your customers that the ID check sent to their email address is associated with your store by using your own dedicated support email address.
For example, Real ID can use your dedicated support email address like `support@yourstore.com` to send ID checks to customers.
You can easily add your own email address to Real ID without making any code changes or changes to your DNS settings. We just send a confirmation link to your email address, after clicking it ID checks will be sent from your email address.
## Getting Started
To get started, first open up Real ID and navigate to **Settings**. Once you have your settings open, select the **Notifications** tab, and make sure you're within the **For Customers** section to see your email settings for customers.

Scroll to the **Send ID checks using your email address section**.
Here you can enter in the preferred name and email address you'd like to use to send ID checks.
After entering in your preferred email address & name, click **Verify**.

You will receive an email to that address from Postmark which is our email provider. Within that email will be a link to confirm your ownership of that account.
:::note
It may take a few minutes for the verification email to appear. If it's still not in your inbox, check your spam folder.
If you're still having issues finding the email, [please contact us](mailto:support@getverdict.com).
:::
Click the confirmation link and your will prove ownership of the account.
Last step, return to Real ID and click the "Check verification status" button. Real ID will now send emails to your customers using your own email address! :tada:
:::warning
You cannot use public email domains like `gmail.com`, `hotmail.com` or `outlook.com` with this feature.
It is not possible for us to verify these domains, you'll need to use a privately owned domain.
:::
### Verifying DKIM Records
For best results, we highly recommend adding DKIM DNS records that help improve the reliability of your emails.
After you've verified ownership of the email address, two DNS records will appear beneath the same **Use your email address** section in the **Notifications** settings:

Click each record's `Host` and `Value` fields to automatically copy them to your clipboard, and paste them into new DNS records.
After you've added the DKIM and Return Path DNS records, click the **Verify** button within the Real ID app to verify the new DNS records.
Then your DNS records will be verified and this will ensure the best deliverability for your ID checks to customers.

:::note
It may take up to 72 hours for DNS records to change. If your DNS records fail to verify after checking for typos, missing characters, or extra spaces, then please try again later.
:::
## Frequently Asked Questions
### This feature is locked on my account. How can I enable it?
This feature is for Business plan subscribers. Upgrading your subscription to Business will unlock the feature. If you need help doing this please contact us.
### I'm getting an error when trying to submit my email
Please note: we can only use private email domains. Public domains like gmail.com, hotmail.com, or apple.com are not supported. If you're using a non-public email and are still having issues, please contact us for support.
### Our Real ID customer emails are being sent to spam
If you haven't yet, [set up DKIM DNS records on your domain](#verifying-dkim-records).
This helps improve the trust for email providers like Gmail, Yahoo and Outlook.
---
// File: triggers/all-orders
# Check all orders
Enabling **Check all orders** will automatically trigger ID verification on all orders. This is especially helpful if you're selling age restricted products, or require ID verification for K.Y.C. purposes.
To enable this trigger, open the **Automations** section of the **Settings** page, enable automatic ID checks, and toggle on **Check all orders**.
---
// File: triggers/high-value-orders
# High value orders
You can require ID verification for all orders above a specific total order price. This is especially helpful for verifying high chargeback risk orders.
When you enable this trigger, also set the threshold for total order value (including tax) that should trigger an ID check.

:::note
At this time the threshold setting is denominated in U.S. dollars, regardless of the currency you have set for your store.
:::
---
// File: triggers/address-mismatch
# Mismatching billing to shipping details
When an order's payment details like the name and address on the payment don't match the name and address on the shipping details, it _could_ be a sign of potential fraud.
Real ID can help save sales and prevent chargebacks by requiring ID verification on these orders.
If the ID matches the billing details, then you have evidence to prove the customer is the true holder of the credit card.

:::note
Within Shopify, this trigger is based off of the [`shippingAddressMatchesBillingAddress`](https://shopify.dev/docs/api/admin-graphql/2023-04/objects/order#field-order-billingaddressmatchesshippingaddress) attribute on the order via the Shopify Admin GraphQL.
:::
---
// File: triggers/high-risk
# High risk level
:::note Shopify only
This trigger relies on Shopify's built-in fraud analysis and is only available on Shopify stores.
:::
Shopify provides [fraud analysis for all orders](https://help.shopify.com/en/manual/orders/fraud-analysis) when using Shopify Payments as your payment gateway.
You can trigger ID checks on orders that have `Medium` or `High` risk based on Shopify's analysis, or any other 3rd party apps that detect potential fraud based on order and customer details.

Please note, that fraud analysis results are not always completed at the same time the order is considered placed. It can take up to several minutes for the fraud analysis to complete.
Real ID will automatically retry retrieving the latest risk analysis 5 minutes after it receives the order initially.
:::tip
Other 3rd party fraud detection apps that add risk analysis to the order in this format are also compatible with this trigger.
:::
---
// File: triggers/specific-products
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# Specific products
You may only require ID verification for an order if the order contains one or more specific products.
You can specify which products require ID verification, or even a whole collection of products in your Shopify store.

To get started, open the **Automations** tab in the **Settings** page. Then scroll down towards the bottom of the page to view the **Products** filter.
Click the toggle beneath the **Collections** tab to activate the filter, then search for your collection. Click on the collection to require ID verification on orders containing one or more products from this collection.

Real ID will automatically track new products added or removed from this collection. So you won't need to manually add products one by one to Real ID.
:::tip
We recommend that you create a separate `ID verification` collection that you can easily add products to. Real ID will automatically sync to collection changes so it's always kept up to date.
:::
Within the **Automations** area of the **Settings** page, scroll down the to **Filters** section to see the products filter:

To enable ID verification on a specific category of products for example, click the toggle under the **Categories** then enable the feature, and click on a collection. Clicking on the collection will require ID verification if the customer's cart contains one or more products from this categories selected.

Lastly, don't forget to click **Save** in the upper right hand corner of the page to save your changes.
Within the **After Checkout Triggers** section of the **Settings** page, find the **Specific Products** toggle. Enable it and select the product categories that should require ID verification.
When an order contains one or more products from a selected category, the customer will be prompted to verify their ID.
For custom integrations, you control product-level ID verification in your own application logic. Use the [REST API](../api/checks.mdx) or [JS SDK](../js.mdx) to conditionally require verification based on the products in the customer's cart or order.
:::info Before checkout flow
This trigger is also available in the [before checkout flow](../flows/before-checkout.mdx#limiting-id-verification-to-specific-products). When used with the before checkout flow, customers will only be prompted to verify their ID if their cart contains products from the specified collections or categories.
:::
---
// File: triggers/us-shipping-states
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# U.S. shipping states
You can set Real ID to only require ID verification on orders that ship to the United States, or only a subset of specific U.S. states.
Within the **Automations** area of the **Settings** page, find the **U.S. shipping state** toggle:

Enable the toggle to require ID verification for orders shipping to the United States. You can choose to verify:
- **All states within the U.S.** - Any order shipping to a US address will require verification
- **Only specific states** - Select individual states (e.g., CA, NY, TX) that require verification
Within the **Automations** area of the **Settings** page, find the **U.S. shipping state** toggle:
Enable the toggle to require ID verification for orders shipping to the United States. You can choose to verify:
- **All states within the U.S.** - Any order shipping to a US address will require verification
- **Only specific states** - Select individual states that require verification
When "Only specific states" is selected, you can search and select the states that should trigger ID verification. Selected states appear as badges above the search box.
Within the **After Checkout Triggers** section of the **Settings** page, find the **U.S. shipping state** toggle:
Enable the toggle to require ID verification for orders shipping to the United States. You can choose to verify:
- **All states within the U.S.** - Any order shipping to a US address will require verification
- **Only specific states** - Select individual states that require verification
When "Only specific states" is selected, you can search and select the states that should trigger ID verification. Selected states appear as badges above the search box.
:::tip Advanced customization
For more complex trigger logic (e.g., combining state with product categories), see the [BigCommerce custom script examples](../bigcommerce/after-checkout.md#custom-trigger-scripts).
:::
For custom integrations, you control state-based verification in your own application logic. Check the customer's shipping state in your backend and use the [REST API](../api/checks.mdx) or [JS SDK](../js.mdx) to conditionally require ID verification for orders shipping to specific U.S. states.
:::tip
This trigger is based on the **shipping address** of the order.
:::
---
// File: triggers/exceptions
# Excluding orders from triggers
You can exclude orders from triggers in the _Exceptions_ area of the settings. Exceptions filter out orders _before_ your automatic triggers are applied, giving you more control over which orders require ID verification.
:::tip
If the exceptions below don't quite fit your needs, you can build a Shopify Flow workflow with our [create an ID check action](../shopify/flow.md) for a more customized trigger. For other platforms, use the [REST API](../api/checks.mdx) to build custom logic.
:::

## Excluding already verified customers
Real ID will exclude orders from ID verification if the customer has already been verified once before.
[Learn more about how verified customers are remembered.](../flows/remember-repeat-customers.mdx)
## Excluding in-store pick up orders
Real ID can exclude orders for in-store pickup from ID verification. Enabling this rule will exclude all pickup orders from triggering an ID check. This might be helpful if you have a process for ID checking in person.

## Excluding orders by shipping line
Real ID can also exclude orders from automatic verification by the shipping line code. For multiple shipping lines, separate them by commas. For example, to exclude both _Standard_ and _Express_ shipping codes, enter `Standard,Express`.

If you need help finding the shipping line code for a given order, [please contact us](https://getverdict.com/) with an example order number and we'll be able to help you find the shipping code.
## Exclude orders by payment gateway
You may want to exclude orders paid through specific gateways because the gateways provide merchant protection.
To exclude multiple payment gateways, separate them by commas. For example, to exclude both _PayPal_ and _Cash on Delivery_ payments, enter `PayPal,Cash On Delivery`.

If you need help finding the payment gateway name for a given order, [please contact us](https://getverdict.com/) with an example order number and we'll be able to help you find the payment gateway name.
## Exclude orders by channel
You may want to exclude orders placed through certain sales channels like Amazon, Walmart, or a specific Shopify app that sources orders from marketplaces.
To exclude multiple channels, separate them by commas. For example, to exclude both _Walmart_ and _Amazon_, enter in `Walmart,Amazon`.

If you need help finding the sale channel name for a given order, [please contact us](https://getverdict.com/) with an example order number and we'll be able to help you find the channel name.
---
// File: triggers/advanced-rules/conditions
# Conditions
Conditions are the building blocks of [advanced rules](./index.mdx). Each condition checks one attribute of the order, cart, or customer.
Some order data — how the order was paid, how it will be delivered, Shopify's fraud analysis — doesn't exist until the order is placed. Conditions that depend on it can only be evaluated in the **After checkout** flow.
## All conditions
| Condition | Matches when… | Before / During checkout | After checkout |
| --- | --- | :---: | :---: |
| All orders | Every order, unconditionally | Yes | Yes |
| Cart total above amount | The cart or order total exceeds the amount you set | Yes | Yes |
| Shipping to country | The shipping address is in one of the selected countries | Yes | Yes |
| Shipping to state/province | The shipping address is in one of the selected states or provinces (US, CA, AU, GB) | Yes | Yes |
| Cart contains products | The cart or order contains one or more of the selected products | Yes | Yes |
| Products with a specific metafield | A product in the cart or order has the `real_id.requires_verification` metafield set to `true` | Yes | Yes |
| Products in collection with a specific metafield | A product belongs to a collection with the `real_id.requires_verification` metafield set to `true` | Yes | Yes |
| Customer tag | The customer's tags contain (or don't contain) a value you set | Yes* | Yes |
| Customer metafield | A text metafield on the customer equals (or doesn't equal) a value you set | Yes* | Yes |
| Billing/shipping address mismatch | The billing address doesn't match the shipping address | — | Yes |
| Credit card payment | The order was paid with a credit card | — | Yes |
| Local delivery | The order uses a local delivery shipping method | — | Yes |
| Order source | The order came from a specific sales channel (e.g., web, POS, draft orders) | — | Yes |
| Order risk level | Shopify's fraud analysis flagged the order at a risk level you select | — | Yes |
* Before checkout, customer conditions require the customer to be logged in to their store account. After checkout, they're evaluated against the order's customer — no login needed.
## Flow compatibility
When you're building rules in the **After checkout** settings, every condition is available. If a rule can *only* match after checkout — meaning it can never be satisfied without post-checkout data — it's marked with a badge in your rules list:

A rule is "after checkout only" when its post-checkout conditions are required for a match. For example:
- *Credit card payment AND shipping to Connecticut* — **after checkout only**: the payment method is never known earlier, so the AND can't be satisfied
- *Credit card payment OR shipping to Connecticut* — works everywhere: before checkout, the shipping state alone can satisfy the OR
### Switching to an earlier flow
If you switch your verification flow to **Before checkout** or **During checkout** while you have "after checkout only" rules enabled, Real ID **disables those rules when you save** and shows you which ones were affected. This prevents a silent gap where a rule appears active but can never match.

To use those rules again, switch back to the **After checkout** flow and re-enable them in the rules list.
## Product metafield conditions
The two metafield conditions let you manage which products require verification **from the Shopify admin**, without touching Real ID settings:
1. In Shopify, create a metafield definition on **Products** (or **Collections**) with the namespace and key `real_id.requires_verification`, type **True or false**
2. Set it to **true** on the products or collections that require ID verification
3. Add the **Products with a specific metafield** (or **Products in collection with a specific metafield**) condition to a rule
From then on, tagging a product for verification is a product-catalog operation — useful when your merchandising team manages restricted items, or when another app sets the metafield for you.
:::note
Metafield conditions require the **read products** permission. If Real ID doesn't have it yet, you'll be prompted to grant it in the settings page.
:::
---
// File: triggers/advanced-rules/examples
# Examples
Recipes for common verification policies. Each example lists the rule's group operator and conditions — recreate them in the rule editor with **Add condition**.
## State-restricted products
**Goal:** only verify customers when a regulated product ships to a state that restricts it — for example, ammunition shipping to Connecticut.
**Rule: "CT ammunition"** — Match ALL (AND)
- **Shipping to state/province** — United States, Connecticut
- **Products in collection with a specific metafield** — set the `real_id.requires_verification` metafield to `true` on your ammunition collection
Orders shipping ammunition anywhere else, or shipping other products to Connecticut, are not verified. Works in every flow.
If several states restrict different product sets, create one rule per state — rules combine with OR, so each policy triggers independently.
## High-value, high-risk orders
**Goal:** screen for fraud without verifying every large order — only orders that are both expensive *and* flagged by Shopify's fraud analysis.
**Rule: "Large risky orders"** — Match ALL (AND)
- **Cart total above amount** — e.g. `500`
- **Order risk level** — Medium, High
This rule uses order risk, so it's **after checkout only**.
## Card-not-present fraud screen
**Goal:** verify orders that show a classic chargeback pattern — paid by credit card with a billing address that doesn't match the shipping address.
**Rule: "Card + address mismatch"** — Match ALL (AND)
- **Credit card payment**
- **Billing/shipping address mismatch**
Both conditions depend on order data, so this rule is **after checkout only**.
## Everyone except wholesale accounts
**Goal:** verify all orders, except from business customers you've already vetted and tagged `wholesale` in Shopify.
**Rule: "All retail orders"** — Match ALL (AND)
- **All orders**
- **Customer tag** — does not contain `wholesale`
Before checkout, the customer must be logged in for the tag to be read. After checkout, the order's customer is used directly.
:::tip
For customers who've completed a Real ID check before, use the [Remember verified customers](../../flows/remember-repeat-customers.mdx) exception instead — it skips repeat verification automatically without tagging.
:::
## Mixed AND/OR logic with nested groups
**Goal:** verify orders shipping to Connecticut that contain *either* ammunition *or* another regulated product line.
**Rule: "CT regulated products"** — Match ALL (AND)
- **Shipping to state/province** — United States, Connecticut
- **Nested group** — Match ANY (OR)
- **Products in collection with a specific metafield** (ammunition collection)
- **Cart contains products** (specific regulated SKUs)
Use **Add nested group** inside the rule editor to build the inner OR group. Groups can be nested up to two levels deep.
---
// File: triggers/advanced-rules/index
# Advanced rules
Advanced rules let you combine trigger conditions with **AND/OR logic** to control exactly which orders require ID verification.
Basic triggers are non-exclusive — if *any* enabled trigger matches, an ID check is sent. That works well for simple policies, but it can't express requirements like:
> "Require ID verification only when the order ships to Connecticut **and** contains ammunition."
With basic triggers, enabling *U.S. shipping states* and *Specific products* separately would send checks for **every** Connecticut order and **every** ammunition order. An advanced rule combines them into a single condition group, so only orders matching **both** are verified.

:::info Availability
Advanced rules are available on the **Automate** and **Protect** plans, on Shopify. If you're on another plan, the **Advanced rules** tab shows a lock — clicking it opens the plans page.
:::
## Where to find it
Advanced rules live in the **Settings** page, in the trigger section of your verification flow:
- **After checkout** — the trigger settings show a **Basic triggers / Advanced rules** switcher at the top. All conditions are available here, since the full order (payment, delivery method, risk analysis) is known after checkout.
- **During checkout** — the same switcher appears in the checkout extension's filter settings. Conditions that depend on data that doesn't exist yet before the order is placed aren't offered here — see [Conditions](./conditions.mdx).

## Switching between basic and advanced
The two modes are mutually exclusive, but **both configurations are always preserved**:
- Switching to **Advanced rules** deactivates your basic triggers. Your basic trigger settings are saved and restored if you switch back.
- Switching to **Basic triggers** deactivates your advanced rules. Your rules are saved and restored if you switch back.
:::caution Rules are shared across all flows
You have **one** set of advanced rules, and it applies wherever ID checks are triggered — before, during, and after checkout. Enabling, disabling, or editing a rule affects every flow at once. If a rule uses conditions that can only be evaluated after checkout and you switch to an earlier flow, Real ID disables that rule for you — see [flow compatibility](./conditions.mdx#flow-compatibility).
:::
## Anatomy of a rule
Each rule has a **name** and a **condition group**. A group matches either **ALL** of its conditions (AND) or **ANY** of them (OR), and groups can be nested up to two levels deep for logic like *(A AND (B OR C))*.

To create a rule:
1. Open the **Advanced rules** tab and click **Add rule**
2. Name the rule — the name appears in your rules list and helps your staff understand the policy
3. Choose **Match ALL (AND)** or **Match ANY (OR)** for the group
4. Click **Add condition** and configure each condition; use **Add nested group** for mixed AND/OR logic
5. Click **Save rule**, then **Save** the settings page
A few things to know:
- **Rules combine with OR.** If any enabled rule matches an order, the customer is sent an ID check. Use multiple rules for independent policies (e.g., one rule per restricted state).
- **Rules can be disabled without deleting them.** Use the **Disable** action in the rules list to pause a policy while keeping its configuration.
- **You can have up to 50 rules.**
- **[Exceptions](../exceptions.mdx) still apply.** Orders from already-verified customers, in-store pickups, and your other configured exceptions are skipped before rules are evaluated.
## Next steps
- **[Conditions](./conditions.mdx)** — every available condition, and which flows support it
- **[Examples](./examples.mdx)** — recipes for common policies
---
// File: triggers/index
import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";
# Triggers
Triggers define which orders should require ID verification. When an order matches one or more of your enabled triggers, Real ID will automatically send an ID check to the customer.
:::info Triggers are non-exclusive
If **any** of your enabled triggers match an order, the customer will be sent an ID check. You don't need all triggers to match — just one is enough.
:::
## Supported triggers by platform
| Trigger | After Checkout | Before Checkout |
| --- | :---: | :---: |
| [All orders](./all-orders.md) | Yes | — |
| [High value orders](./high-value-orders.md) | Yes | — |
| [Address mismatch](./address-mismatch.md) | Yes | — |
| [High risk level](./high-risk.md) | Yes | — |
| [Specific products / collections](./specific-products.mdx) | Yes | Yes |
| [U.S. shipping states](./us-shipping-states.mdx) | Yes | — |
:::tip Need to combine triggers?
Basic triggers use OR logic — any match sends an ID check. To require a **combination** of conditions (e.g., shipping to a specific state *and* the order contains a restricted product), use [Advanced rules](./advanced-rules/index.mdx), available on the Automate and Protect plans.
Real ID also integrates with [Shopify Flow](../shopify/flow.md) if you'd rather drive ID checks from your own Flow automations.
:::
| Trigger | After Checkout | Before Checkout |
| --- | :---: | :---: |
| [All orders](./all-orders.md) | Yes | — |
| [High value orders](./high-value-orders.md) | Yes | — |
| [Address mismatch](./address-mismatch.md) | Yes | — |
| [Specific products / categories](./specific-products.mdx) | Yes | Yes |
| [U.S. shipping states](./us-shipping-states.mdx) | Yes | — |
:::note
The **High risk level** trigger is not available on WooCommerce, as it relies on Shopify's built-in fraud analysis.
:::
| Trigger | After Checkout |
| --- | :---: |
| [All orders](./all-orders.md) | Yes |
| [High value orders](./high-value-orders.md) | Yes |
| [Address mismatch](./address-mismatch.md) | Yes |
| [Specific product categories](./specific-products.mdx) | Yes |
| [U.S. shipping states](./us-shipping-states.mdx) | Yes |
BigCommerce also supports **custom trigger scripts** for advanced logic. See the [BigCommerce custom trigger documentation](../bigcommerce/after-checkout.md#custom-trigger-scripts) for examples.
Custom integrations don't use built-in triggers — you control when ID checks are created in your own application logic.
Use the [REST API](../api/checks.mdx) to create checks server-side based on your own conditions, or use the [JS SDK](../js.mdx) to gate checkout or any page element on the frontend.
## Exceptions
You can also exclude certain orders from triggering ID checks — for example, orders from already-verified customers or in-store pickup orders. See [Exceptions](./exceptions.mdx) for details.
## Custom integrations
If the built-in triggers don't cover your use case, you can build custom integrations:
- **[REST API](../api/checks.mdx)** — Create ID checks programmatically from any platform or backend system
- **[JS SDK](../js.mdx)** — Trigger ID verification from your frontend with full control over the experience
These options work on all platforms and give you complete flexibility over when and how ID checks are created.
---
// File: woocommerce/activation
# Billing & Activation
Real ID for WooCommerce uses a license key system managed through a separate billing dashboard. This guide covers how to sign up, activate your plugin, and manage your subscription.
## Signing Up for a License Key
To get started with Real ID on WooCommerce:
1. Go to the [billing dashboard](https://dashboard.getverdict.com) and create an account
2. Select a plan and complete the purchase
3. Once purchased, your license key will appear in your account
To view your license keys, open the [**Account** tab](https://dashboard.getverdict.com/account) in the billing dashboard.
Copy your license key for the next step:

For current pricing details, visit our [pricing page](https://getverdict.com/pricing).
## Activating the Plugin
Once you have your license key:
1. Go to your WordPress admin dashboard
2. Open the **Real ID** plugin
3. Click on the **Settings** tab
4. Open the **Billing** section
5. Enter your license key and save
Your plugin is now activated and Real ID will begin processing ID checks with actual results.
:::info Test Mode
When you first install the Real ID plugin, it's automatically placed in test mode. This allows you to try ID checks with a free demo experience before activating with a license key.
:::
## Managing Your Subscription
All subscription management is handled through the [billing dashboard](https://dashboard.getverdict.com). After logging in, you can:
- View your current plan and usage
- Upgrade or downgrade your subscription
- Purchase additional license keys
- Access your billing history
### Accessing the Customer Portal
To manage payment methods, view invoices, or make changes to your subscription:
1. Log in to the [billing dashboard](https://dashboard.getverdict.com)
2. Open the **Account** tab
3. Click **Open customer portal**

The customer portal allows you to:
- **Update payment method** — Change your credit card on file
- **View invoices** — Download past invoices and receipts
- **Change plan** — Upgrade or downgrade your subscription
- **Cancel subscription** — End your Real ID subscription
## Canceling Your Subscription
To cancel your Real ID subscription:
1. Log in to the [billing dashboard](https://dashboard.getverdict.com)
2. Open the **Account** tab
3. Click **Open customer portal**
4. Click **Cancel plan** or **Cancel subscription**
5. Confirm the cancellation
:::warning Before You Cancel
Make sure to download any ID check photos or data you need before canceling. See [Downloading Customer Photos](../for-merchants/downloading-customer-photos.md) for instructions.
:::
### What Happens After Cancellation
When you cancel your subscription:
- **Access until period end** — Your license key remains active until your current billing period ends
- **No further charges** — You won't be charged after the current period
- **Plugin reverts to test mode** — Once your license expires, the plugin will return to test mode
- **Data retention** — Your ID check data will be retained for 90 days after your subscription ends, then permanently deleted
### Reactivating After Cancellation
If you want to use Real ID again after canceling:
1. Log in to the [billing dashboard](https://dashboard.getverdict.com)
2. Purchase a new subscription
3. Enter your new license key in the plugin settings
If you reactivate within 90 days, your previous ID check data will still be accessible.
## Multiple License Keys
If you operate multiple WooCommerce stores, you'll need a separate license key for each site.
To purchase additional license keys:
1. Log in to the [billing dashboard](https://dashboard.getverdict.com)
2. Purchase an additional subscription
3. Each subscription provides a unique license key for one site
:::warning One License Per Site
For security, each license key is locked to a single site URL when first activated. You cannot use the same license key on multiple sites.
:::
## Frequently Asked Questions
### How can I see my current license key?
You can view your currently activated license key by opening the Real ID plugin and navigating to **Settings** → **Billing**.

### I'm having issues reactivating the plugin after changing my site URL
For security, Real ID locks your license key to your site's URL when first activated. If you change your site's URL after activation, ID verification syncing and other features may stop working.
To migrate your license key to a new site URL, please [contact our support team](https://getverdict.com/contact).
### What happens if my license key expires?
When your license key expires (either from cancellation or non-payment):
- The plugin reverts to test mode
- New ID checks will use test/demo results
- Existing ID check data remains accessible for 90 days
To restore full functionality, purchase a new subscription and enter the new license key.
### Will canceling affect my existing orders?
No. Canceling Real ID will not modify, cancel, or refund any of your WooCommerce orders. ID verification will simply stop processing for new orders, and any order metadata added by Real ID will remain intact.
---
// File: woocommerce/connection-status
# Connection Status & Troubleshooting
The **Connection Status** card on the WooCommerce settings tab confirms that the Real ID API can reach your WordPress site. This bidirectional reachability is required for post-checkout verification status to sync back to your orders. If a customer completes their ID check but their WooCommerce order's metadata never updates, the connection is the first thing to check.
## Where to find it
In your WordPress admin: **Real ID → Settings → Status tab**. The first card on the tab is **API Connection Status**.
It runs automatically when you open the tab. Use the **Retry** / **Re-check connection** button to run it again on demand. The Status tab also has a shortcut to view your Real ID logs in WooCommerce and a button to refresh the plugin's cache.
## What the check does
When you (or the auto-check) trigger it, the Real ID plugin asks our API to call back to your site at:
```
GET /wp-json/real-id/v1/version
```
…using your shop's license key as the `Authorization: Bearer ` header. The same code path our backend uses when it syncs verification status onto your orders. So if this check passes, every other webhook callback we make will also reach your site.
## Status meanings
| Status | What it means | What to do |
|---|---|---|
| ✅ **Connected** | Our API reached your site, your license key was accepted, and the plugin responded with version info. | Nothing — sync should be working. |
| ⚠️ **License not activated** | No license key is set on the plugin yet. | Activate the license under **Real ID → Billing**. |
| ⚠️ **Authentication failed** | Your site responded but rejected our license key. | Re-activate the license. If it persists, your stored license key may be out of sync with our records — contact support. |
| ❌ **Plugin route not found** | Our request reached WordPress, but `/wp-json/real-id/v1/version` returned 404. | Make sure the Real ID plugin is **active** and updated to the latest version. |
| ❌ **Blocked by firewall or WAF** | Our request returned 403 with a non-JSON body — typical of a Cloudflare, Sucuri, or hosting-level firewall blocking `/wp-json/*` before it reaches WordPress. | See [the WAF / Cloudflare section below](#blocked-by-firewall-or-waf). This is the **most common** cause when sync silently stops working on a previously-healthy site. |
| ❌ **Request timed out** | Our request didn't get a response within 8 seconds. Often caused by a JS-challenge bot protection (Cloudflare Bot Fight Mode, Super Bot Fight Mode) — our backend cannot solve a browser challenge and the request just hangs. | Disable the JS challenge for `/wp-json/real-id/v1/*`, or allowlist requests carrying a `Bearer` Authorization header. |
| ❌ **Site unreachable** | DNS failed or the site refused the connection. | Confirm the site is online and resolves publicly (`curl -I https://yourdomain.com`). |
| ❌ **Real ID API unreachable** | Your WordPress site couldn't reach the Real ID API itself — the failing leg is on our side, not yours. | Usually transient. Wait a few minutes and retry. If it persists, contact Real ID support. |
| ❌ **Unexpected response** | The site responded with something we didn't recognize. | Contact support and share the response body shown on the card. |
## Blocked by firewall or WAF
If the indicator is red with **Blocked by firewall or WAF**, a layer in front of WordPress is rejecting our requests. Common culprits:
### Cloudflare (most common)
1. Open your Cloudflare dashboard → select the zone for your site.
2. Go to **Security → Bots → Configure Super Bot Fight Mode**.
- If "Definitely automated" is set to **Block**, our backend (which runs from cloud serverless platforms) is being flagged.
- Either set this to **Allow** for `/wp-json/real-id/v1/*`, or add a WAF skip rule:
3. Go to **Security → WAF → Custom rules** and add a rule:
- **Field**: `URI Path`, **Operator**: `starts with`, **Value**: `/wp-json/real-id/v1/`
- **And**: `HTTP Request Header` — `Authorization`, **Operator**: `starts with`, **Value**: `Bearer `
- **Action**: `Skip` → check **All remaining custom rules**, **Bots**, **Managed rules**.
### Kinsta hosting firewall
Kinsta hosts many WP sites and proxies through Cloudflare. In **MyKinsta dashboard → your site → Tools → IP Deny**, confirm there are no rules blocking external IPs broadly. If you have **Kinsta APM** or custom rules, review those for `/wp-json/*` patterns.
### WordPress security plugins
Plugins like **Wordfence**, **iThemes Security**, or **All In One WP Security** can block REST API access. Check for:
- "Block REST API for non-logged-in users" toggles — disable for `/real-id/v1/*` paths
- IP-based rate limiting that may be flagging our serverless egress
### Why we can't just give you an IP allowlist
Our backend runs on AWS Lambda and Vercel, so the source IP rotates across a large pool. There's no fixed IP set we can hand you to allowlist. Instead, allowlist by **path + Authorization header**, as shown in the Cloudflare example above.
## What to do after fixing the block
1. Go back to **Real ID → Settings → Status** in WordPress admin
2. Click **Re-check connection**
3. The status should turn green within a few seconds
Your in-flight verification syncs will resume on their next QStash retry — there's nothing additional to manually replay on your end. If you have specific orders you suspect missed their sync, contact support with the order IDs.
---
// File: woocommerce/hooks
# WordPress Hooks
You can use hooks to extend Real ID into your own WordPress code.
:::tip Webhooks also available
You can also [use webhooks](../api/webhooks.mdx) to subscribe to ID verification events as well.
:::
## ID verification status changes
You can subscribe in real time when customers submit their ID photos with the `id_verification_status_changed` hook.
This hook will fire whenever a customer's ID verification status changes.
:::info Order status changes
This hook will also emit on _order_ verification status changes. For example, if an [already verified customer](../flows/remember-repeat-customers.mdx) places another order, this hook will also fire, since this new order is now considered verified.
:::
### `id_verification_status_changed`
This hook will emit every single time a customer or order's ID verification status changes.
#### Parameters
This hook passes a single associative array:
- `check_id` - the unique ID verification token tied to the customer
- `new_status` - the status being applied to the order. [See `metadata` for a complete list](./metadata.md).
- `customer_id` - the customer's WordPress user ID
- `order_id` the WooCommerce order ID
:::info Relies on webhooks
Metadata updates rely on your site being reachable by the [Real ID service by webhook](./webhooks.md).
Webhooks are asynchronous checkout or order events, they may not happen at the same time as a new order being placed, etc.
:::
#### Examples
This simple example will log these changes to your [WooCommerce logs](https://woocommerce.com/document/finding-php-error-logs/) so you can see the trail of changes of ID verification status updates:
```php
// Subscribing to the update, and logging the change to the WooCommerce Status Logs
add_action('id_verification_status_changed', function($params) {
$logger = wc_get_logger();
$logger->info('ID verification status changed for an order', [
"source" => "Real ID",
"new_status" => $params["new_status"],
"order_id" => $params["order_id"],
"customer_id" => $params["customer_id"],
"check_id" => $params["check_id"],
]);
}, 10, 1);
```
You can also use the `order_id` to retreive the current order details:
```php
// Subscribing to the update, and retrieving the order associated with the ID check:
add_action('id_verification_status_changed', function($params) {
$order_id = $params["order_id"];
if(empty($order_id)) {
// it's possible that only the customer metadata is changing
return;
}
$order = get_wc_order($order_id);
// check the current fulfillment, payment statuses, etc.
}, 10, 1);
```
## Frequently Asked Questions
## Will this hook be called from new orders from already verified customers?
Yes, even though technically it's not an ID verification event by the customer, the order's metadata is updated with the ID check details on a new order by an already verified customer.
## This hooks fires multiple times
Yes, it's possible for this hook to fire multiple times for the same event, this is by design to make sure that your metadata is up to date.
Please make sure your extension logic is [idempotent](https://www.freecodecamp.org/news/idempotence-explained/) and accounts for the possibility of multiple calls for the same event.
### How is this hook called?
The Real ID service emits webhooks to your WordPress site when customers progress through ID verification.
### This hook is delayed or isn't firing at all in our tests
Make sure your site is publicly accessible to the internet and you haven't recently change your site's home URL.
If you don't see any incoming webhooks from the Real ID service on your WordPress site whatsoever; then that most likely means that your site's URL has changed and it needs to be updated.
[Contact our support](https://getverdict.com/help/contact) if you continue to have issues with metadata or hooks not firing properly.
---
## Creating ID checks programmatically
You can create ID checks directly from your own PHP code using the `real_id_create_check()` function. This is useful for:
- **Custom trigger logic** - Implement complex AND conditions that aren't possible with built-in rules
- **Custom thank-you pages** - Trigger verification on Elementor or other page builder pages
- **Customer registration** - Verify identity during account creation (without an order)
- **Custom workflows** - Integrate ID verification into any part of your site
### `real_id_create_check($args)`
Creates an ID verification check and optionally displays the verification widget.
#### Parameters
| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `order_id` | int | No* | `null` | WooCommerce order ID. If provided, customer data is extracted automatically. |
| `customer_id` | int | No | `null` | WordPress user ID to associate with the check. |
| `email` | string | No* | `null` | Customer email address. |
| `phone` | string | No | `null` | Customer phone number. |
| `first_name` | string | No | `null` | Customer first name. |
| `last_name` | string | No | `null` | Customer last name. |
| `display_widget` | bool | No | `true` | Whether to render the verification widget. |
| `display_mode` | string | No | `'full'` | Widget display mode: `'full'` (inline) or `'modal'` (overlay popup). |
| `target` | string | No | `null` | CSS selector for custom mount point. If not provided, `widget_html` includes a mounting div automatically. |
:::info Required parameters
Either `order_id` OR `email`/`phone` is required. If you provide `order_id`, customer contact info is extracted from the order automatically.
:::
#### Return Value
**On success**, returns an array:
```php
[
'success' => true,
'check_id' => 'abc123...', // Unique check identifier
'check' => [...], // Full check object from API (null if from cache)
'from_cache' => false, // Whether check ID was retrieved from session cache
'widget_html' => '...' // Complete HTML (div + script) - just return this from your shortcode
]
```
**On error**, returns a `WP_Error` object with one of these codes:
- `invalid_order` - Order ID provided but order not found
- `missing_contact` - No email or phone provided
- `no_license` - Real ID license key not configured
- `api_error` - API request failed
#### Examples
**Basic shortcode usage (recommended):**
```php
add_shortcode('my_verification', function() {
$result = real_id_create_check(['order_id' => 123]);
if (is_wp_error($result)) {
return '';
}
// widget_html includes everything needed (mounting div + script)
return $result['widget_html'];
});
```
**Modal display mode:**
```php
add_shortcode('modal_verification', function() {
$result = real_id_create_check([
'order_id' => 123,
'display_mode' => 'modal' // Shows as popup overlay
]);
if (is_wp_error($result)) {
return '';
}
return $result['widget_html'];
});
```
**Without displaying widget (email/SMS only):**
```php
// Just send the verification request via email/SMS
// Don't display anything on the page
real_id_create_check([
'order_id' => 123,
'display_widget' => false
]);
```
**With custom target (advanced):**
```php
// Use this if you need custom styling or an existing element
add_shortcode('custom_verification', function() {
$result = real_id_create_check([
'order_id' => 123,
'target' => '#my-custom-div', // Your own element
]);
if (is_wp_error($result)) {
return '';
}
// When using custom target, you provide the element
return '' . $result['widget_html'];
});
```
### Custom Thank-You Page Example
If you're using Elementor or another page builder with a custom thank-you page, you can create a shortcode that triggers ID verification with custom AND conditions:
```php
// Add this to your theme's functions.php or a custom plugin
add_shortcode('my_id_verification', function() {
// Payment gateways that require ID verification (add more as needed)
$required_gateways = [
'cod', // Cash on delivery
'bacs', // Bank transfer
// Add more gateway IDs here
];
// Minimum order total to trigger verification
$minimum_order_total = 200;
// Get order ID from URL parameters
$order_id = isset($_GET['order-received']) ? absint($_GET['order-received']) : null;
if (!$order_id) {
$order_id = isset($_GET['order_id']) ? absint($_GET['order_id']) : null;
}
// Some page builders use ?key=wc_order_xxx format
if (!$order_id && isset($_GET['key'])) {
$order_key = sanitize_text_field($_GET['key']);
$order_id = wc_get_order_id_by_order_key($order_key);
}
if (!$order_id) {
return ''; // No order found
}
$order = wc_get_order($order_id);
if (!$order) {
return '';
}
// Check conditions: order total > minimum AND payment gateway in list
$order_total = (float) $order->get_total();
$payment_method = $order->get_payment_method();
if ($order_total <= $minimum_order_total || !in_array($payment_method, $required_gateways)) {
return ''; // Conditions not met
}
// Conditions met - create ID verification check
$result = real_id_create_check(['order_id' => $order_id]);
if (is_wp_error($result)) {
return '';
}
return $result['widget_html'];
});
```
Then add the shortcode `[my_id_verification]` to your Elementor thank-you page.
### Hook-Based Integration
You can also trigger checks from WooCommerce hooks. Since hooks run in the background (not during page rendering), you must set `display_widget` to `false`:
```php
// Trigger verification when order status changes to processing
add_action('woocommerce_order_status_processing', function($order_id) {
$order = wc_get_order($order_id);
// Your custom conditions
$is_high_risk = /* your logic */;
$is_new_customer = /* your logic */;
// AND condition: high risk AND new customer
if ($is_high_risk && $is_new_customer) {
real_id_create_check([
'order_id' => $order_id,
'display_widget' => false // Required for hooks - sends notification only
]);
}
});
```
### Action Hook Alternative
You can also use the `real_id_trigger_check` action hook:
```php
// These are equivalent (for notification-only checks):
real_id_create_check(['order_id' => 123, 'display_widget' => false]);
do_action('real_id_trigger_check', ['order_id' => 123, 'display_widget' => false]);
```
### Display Modes
| Mode | Description | Use Case |
|------|-------------|----------|
| `'full'` | Widget renders inline where shortcode is placed | Thank-you pages, dedicated verification pages |
| `'modal'` | Widget appears as a popup overlay | Less intrusive, doesn't interrupt page layout |
### Frequently Asked Questions
#### Will this create duplicate checks?
If a check already exists for the order, the API may return the existing check instead of creating a duplicate. However, it's best practice to check if verification is needed before calling this function.
#### Can I customize what the widget looks like?
Yes, the widget uses your [theme settings](../theming/branding.md) configured in the Real ID dashboard, including colors and logo.
#### Does this work with the built-in automatic rules?
Yes, this function works independently of the built-in rules. You can use both:
- Built-in rules for simple OR conditions (e.g., "order over $100 OR contains alcohol")
- `real_id_create_check()` for complex AND conditions or custom workflows
#### Why isn't the widget appearing?
Make sure:
1. The Real ID plugin is activated and up to date
2. You have a valid license key configured
3. The function is called during page rendering (not in an AJAX handler or background process)
4. `display_widget` is `true` (the default)
5. Your shortcode returns `$result['widget_html']`
---
// File: woocommerce/logs
# Real ID logs
The Real ID plugin will log crucial events around when orders are processed, ID checks are triggered, and when ID checks are associated with customers and orders.
You can download these logs from the WooCommerce plugin at any time. Please include them on support tickets so we can help troubleshoot integration or assocation problems.
## Finding the Real ID logs
First, log into your WordPress admin. Then hover over the the **WooCommerce plugin** and click the **Status** page:

In the status page, open the **Logs** tab:

Here you should see a list of log files. The `real_id` log files will be split by day, select the log files you'd like to download, then click the action menu and select _Download_. Then click the _Apply_ button to download the log files:

Then attach these to your support ticket with Real ID.
## Frequently Asked Questions
### I don't see any `real_id` logs in my WooCommerce site
Most likely you don't have logging enabled on your site. To check, from the _Logs_ page, click the **Settings** link just below the tab.
Make sure that logging is enabled, and that your minimum log level is set to _None_. Also, make sure that your retention of logs is a reasonable amount of time, we recommend at least 30 days.
Below is an example of these logging settings:

---
// File: woocommerce/metadata
# ID check Metadata on WooCommerce orders and users
Real ID will automatically sync the status of your ID checks to WooCommerce orders and customers for you. It leaves two special custom metafields:
- `real_id_check_status` - the current status of the ID check
- `real_id_check_id` - the specific ID check associated with this customer or order
## Viewing an order's metadata
You can see both the `real_id_check_status` and `real_id_check_id` for a given order in the WooCommerce plugin.
First open the order, then scroll down to the **Custom Fields** section. Here you can see the metadata for the order, and there you can see the specific ID check unique token and the current status of the ID check:

## List of Real ID check statuses
The metadata key `real_id_check_status` is the current state of the ID check. It's kept in sync as the customer progresses through their ID check process.
This metadata is kept in sync during the customer's ID verification lifecycle. Here are all of the possible statuses of the `real_id_check_status` key:
- `delivered` - the ID check has been delivered to the customer by email or SMS, or shown within your store if you have ID verification required before checkout.
- `opened` - the customer opened the ID check
- `submitted_id` - the customer has submitted their ID, but has not yet submitted their selfie yet (if headshot capture is enabled)
- `in_review` - the ID check has warnings such as an Expired ID that require a manual approval
- `failed` - the ID check failed conclusively, check the ID check details for more information
- `completed` - the customer successfully completed their ID check
- `manually_approved` - a staff member manually approved the ID check
- `manually_rejected` - a staff member manually rejected the ID check
- `expired` - the customer was previously verified, but their ID's expiration date has since passed, so Real ID has invalidated the verification. The customer will be prompted to verify again on their next order. See [Expired IDs](../flows/remember-repeat-customers.mdx#expired-ids).
### Accessing the current user's metadata in PHP
You can use the `get_user_meta` function in WordPress to retrieve the current user's verification status for example:
```php
```
## How order and customer metadata are synchronized with the ID check
Real ID sends secure webhooks to your WooCommerce or WordPress instance as customers progress through their ID check. If you're seeing a delay or missing updates, make sure that your WooCommerce and WordPress instance is accessible to the internet, and has not changed site names.
---
// File: woocommerce/ninja-forms
# Adding ID Verification to Ninja Forms
You can add ID verification to your Ninja Forms on your WooCommerce website with just a few clicks.

Ninja Forms is a great plugin for creating custom forms to collect rich data from your customers. You can easily create a form to collect text, dates, and more. You can require ID verification to submit the form, and the ID photos and optional selfies from your customers will be verified and displayed within the Real ID plugin.
## Prerequisites
Before we get started, make sure you have these plugins installed on your WordPress site:
1. [WooCommerce](https://wordpress.org/plugins/woocommerce/)
2. [Real ID](https://wordpress.org/plugins/identity-verification-for-woocommerce/#description)
3. [Ninja Forms](https://wordpress.org/plugins/ninja-forms/)
## Getting Started
First, you'll need to activate Real ID to verify IDs with the **Before Checkout** flow. It just takes a few clicks, and [this guide will show you how](../flows/before-checkout.mdx).
### Activating Ninja Forms Developer Mode
To create the ID verification field in your Ninja Form, you'll need to enable Development Mode in Ninja Forms. This will give us extra options to use when creating the form.
To enable developer mode, open the Ninja Forms **Settings** page:

Then scroll down to the **Advanced** settings, and enable **Developer Mode**. Don't forget to click **Save** as well.

### Adding the ID Verification Field to Your Ninja Form
Next, create a new Ninja Form, or edit your existing form. This will open the Ninja Form builder.
Within the builder, if you haven't yet, add a **Submit** field. This will allow forms to be submitted:

Click the gear icon on the right-hand side of the **Submit** button to open its settings in the right-hand panel.
Then open the **Display** option and under the **Container** field, enter `verify-id-prompt`.
This change will add the CSS class `.verify-id-prompt` to the Submit button's HTML. This triggers Real ID to replace the Submit button with an ID verification prompt for unverified customers.

Then click **Done** in the top-right corner to save these changes to the **Submit** button.
And that's it! Your form will now have an ID verification field. Customers will be required to verify their ID to submit the form.
:::tip ID verification won't show in the Ninja Form builder
If you don't see the ID verification prompt in the form builder in Ninja Forms, don't worry—this is normal.
The ID verification field will appear in the live form. Try it on a page in your WordPress site to view it.
:::
## Frequently Asked Questions
### Will ID verification show for already verified customers?
No, the Submit button will appear for already verified customers, either if they're logged in or if their browser has been remembered.
### Is this compatible with the blocks and/or shortcodes version of Ninja Forms?
Yes, you can use this method of integrating Real ID using the shortcode or the blocks version of Ninja Forms in your WordPress pages or whereever shortcodes are supported.
### Can I change the placement of the ID verification field?
Yes, this example shows how to place ID verification at the very end of your form, just before submission. However, you can add the `verify-id-prompt` class to any field in your form. Real ID will replace that field with ID verification.
We recommend using the **HTML** field for this, so you can place an empty field or show a successfully verified message to your customer that's only shown after they verify their ID.
### I'm still having trouble, can I get help?
Of course! We're happy to help. [Please contact us for assistance](https://getverdict.com/contact).
---
// File: woocommerce/order-statuses
# Order Statuses
Real ID can sync the ID check results to your WooCommerce orders. This allows you to hold orders if an ID check is required for the order.
Once the customer completes the ID check, then the order can be released. Or if the ID check fails, then the order will fail.
This allows you to automate your fulfillment for orders if they require ID verification.
## Setting up order status syncing
To enable this feature, open the **Settings** area of the plugin. Then click on the **WooCommerce** tab.
Here you can enable syncing of ID checks to orders status fields:

You can use the dropdowns to change the order status assigned to each stage of an ID check.
The default for ID checks in progress is `On hold`. But you can change it to any status.
:::tip
If you have custom order statuses for your store, they will be automatically populated as options in the dropdown as well.
:::
## Frequently Asked Questions
### Will enabling this feature cause failed ID checks to cancel & refund payments?
No, Real ID does not cancel transactions or refund transactions. This feature only affects the order status filed on the WooCommerce order.
### Where are the list of available WooCommerce order statuses?
You can find a complete list of available WooCommerce order statuses and a helpful flow diagram to understand the transitions between them here:
https://woocommerce.com/document/managing-orders/
---
// File: woocommerce/permissions
# User Permissions
Real ID for WooCommerce limits who can open the **ID Checks** admin pages based on the user's WordPress capabilities. By default, two built-in roles can manage the plugin:
- **Administrator** — full WordPress administrative access
- **Shop Manager** — the standard WooCommerce role for store staff
If you need someone else to manage Real ID, grant them either role (or one of the capabilities listed below), and they'll be able to open the plugin without any further configuration.
## Capabilities That Grant Access
A user can open Real ID if they have **any** of the following WordPress capabilities:
| Capability | Granted to by default | When to use it |
| --- | --- | --- |
| `manage_options` | Administrators | Already covered — no action needed for site administrators |
| `manage_woocommerce` | Administrators, Shop Managers | Already covered — no action needed for store staff using the standard WooCommerce role |
| `manage_real_id` | No one by default | Use this when you want to grant Real ID access to a **custom role** without also giving them broader WordPress or WooCommerce permissions |
Holding any one of these capabilities grants the user access to the **ID Checks** menu, the **New ID check** screen, and the plugin **Settings** — including triggers, rules, branding, email setup, and license management.
## Choosing Between Administrator and Shop Manager
For most stores, a **Shop Manager** is the right role for staff who handle orders, checks, and customers day-to-day. Reserve the **Administrator** role for users who also need to install plugins, change WordPress settings, or manage other users.
| If the user needs to… | Grant role |
| --- | --- |
| Review ID checks, manage triggers, update Real ID settings | Shop Manager |
| All of the above plus install/update plugins or change WordPress config | Administrator |
## Granting Access to a Custom Role
If you've created a custom role (for example, a "Verification Reviewer" or "Compliance Staff" role) and want it to manage Real ID **without** granting broader WooCommerce or WordPress access, give the role the `manage_real_id` capability.
The easiest way is with a role-management plugin such as [User Role Editor](https://wordpress.org/plugins/user-role-editor/) or [Members](https://wordpress.org/plugins/members/):
1. Open the role-management plugin
2. Select the custom role
3. Add the **`manage_real_id`** capability
4. Save
You can also do this in code by adding to your theme's `functions.php` or a small custom plugin:
```php
add_action('init', function () {
$role = get_role('your_custom_role');
if ($role) {
$role->add_cap('manage_real_id');
}
});
```
:::tip Why `manage_real_id` for custom roles
Granting `manage_options` would give the user access to every WordPress setting on the site, and `manage_woocommerce` would expose all WooCommerce admin features. `manage_real_id` is scoped specifically to the Real ID plugin, so it's the right choice when you want to limit a custom role's access to ID verification only.
:::
## Verifying a User Has Access
To confirm a user can access Real ID:
1. Log in to WordPress as that user (or use a tool like [User Switching](https://wordpress.org/plugins/user-switching/))
2. Look for the **ID Checks** item in the left-hand admin menu
3. Click into it and confirm the plugin loads without a "You do not have sufficient permissions" message
If the menu item is missing, the user does not currently have any of the three capabilities. Re-check their assigned role or capabilities and try again.
## A Note on Access Scope
Any user who can open Real ID can perform every action inside it — including changing settings, approving or rejecting checks, deleting check data, and managing the license. There are no per-feature sub-permissions today, so only grant access to users you trust with all of those actions.
---
// File: woocommerce/shortcodes
# ID verification status short code
If you need to show the currently logged in user's verification status, you can do so with the `[real_id_current_user_verification_status]` shortcode.
This shortcode looks up the current ID verification status of the current user and displays it within the page.
```php
[real_id_current_user_verification_status]
```
## Showing a specific user's verification status
Using the `real_id_user_verification_status` shortcode, you can display the user's ID verification status.
Pass the ID of the user via the `user_id` argument to the shortcode to only display the ID verification status of that particular user:
```php
[real_id_user_verification_status user_id=1]
```
## Styling the displayed verification status
The shortcode will display a span with the class `.real-id-unverified` if the customer isn't verified yet, or `.real-id-verified` if they are verified.
You can add CSS to your theme to override the styling of these two elements if needed.
---
// File: woocommerce/support-account
# Create a temporary account for Real ID support
There might be cases when you need us to provide support for an issue either with a specific ID check, configuration with your site or issues activating your license key. For these screenshots and specific examples of actions are highly appreciated.
However, due to the flexibility of WordPress and all of the possible plugins and themes, it may not be possible for our support staff to recreate your issue and we'll need to see it firsthand to provide further support.
You can create a temporary account for us to securely login and help troubleshoot and solve any issues.
## Create a new user
First, login to your WordPress backend. Then on the left hand menu, select the **New User** option:

Then in the new form enter in the following:
1. For the `username` field you can use `real-id-support`
2. For the `email` field use the email address `support@getverdict.com`
3. Select the `Administrator` role so our support team has the access needed to troubleshoot site-level issues (the Real ID plugin itself is also accessible to Shop Managers — see [User Permissions](./permissions.md) — but Administrator is preferred for support sessions)
4. Click **Save** to create the administrator role
If you have emails setup on your WordPress site, no further action is necessary. We'll be notified on our support email inbox and we'll be able to login and assist.
However, if you do not have emails enabled, please share the generated password with us securely using a tool like 1Password.
## Deactivating the support account
After we have resolved the issue, you can safely deactivate the account. First, click the **Users** page on the left hand menu in your WordPress backend. Then search for the `support@getverdict.com` user you created in the prior steps.
You can hover your mouse over the temporary account and click **Delete** to permanently delete it. Or alternatively you can demote it to a `Subscriber` role to remove it's administrative role.

---
// File: woocommerce/verification-page
# Embed ID verification into a WordPress page
You can embed the ID verification flow into any page on your WordPress site using our [JS SDK](../js.mdx).
You can set the ID verification flow to prompt for ID immediately, or gate a button or form until the customer is verified.
## Add a new HTML block
In the WordPress page editor, type `/` to choose a new block. In the search bar, type in `HTML` and choose the `Custom HTML` block:

Paste this bit of code in the new block:
```html
```
Now save the page and this will result in the ID verification prompt to display on the page:

:::note ID gating specific buttons or forms
This example uses the `full` example. But you can also use the `modal` mode to gate a specific HTML element. More details on how to use [this mode here](../js.mdx).
:::
## Already verified customers
This JS SDK will remember already verified customers automatically. It will attempt to find the customer's past ID check based on their account and/or browser.
## Questions
If you have any questions about setting up this page, [please contact us](https://getverdict.com/contact).
---
// File: woocommerce/webhooks
# Set up WooCommerce Webhooks
Real ID relies on WooCommerce order hooks in order to send ID checks according to your triggers.
If you have issues with ID checks triggering late or not at all with the [after checkout](../flows/after-checkout.mdx) flow, then this guide will help you improve ID check deliverability by setting up a order created webhook.
:::tip
This guide only applies to merchants using the WooCommerce Real ID plugin with the [after checkout flow](../flows/after-checkout.mdx).
It won't apply to you if you're using the Real ID Shopify app, or are requiring ID verification [before checkout](../flows/before-checkout.mdx).
:::
## How it works
In WooCommerce you can set up webhooks, which are notifications sent to specific URLs when specific _events_ on your store happen.
Example of events include:
* `Order created` - fired when a new order is placed
* `Customer created` - fired when a new customer registers an account
* Etc.
In this guide we'll show you how to set up a WooCommerce Webhook that notifies Real ID whenever an new order is placed.
If you're using the default *Thank You* page, you most likely won't need to set up this webhook,
:::info
By default, Real ID integrates into your WooCommerce store's *Thank You* page. But if your store is using a custom URL for the *Thank You* page, it might break the order syncing with Real ID.
:::
## Getting started
First, login into WordPress and open the WooCommerce plugin settings.
Then select the *Advanced* tab, and then the *Webhooks* section.

You'll just need to fill out the fields with these values:
1. For the *Name* field, enter in `Real ID order syncing`.
2. For the *Status* field, set the webhook to `Active`.
3. For the *Topic* field, select the `Order created` topic.
4. For the *Delivery URL*, copy and paste this link: `https://real-id.getverdict.com/api/webhooks/wc/direct/orders`
5. For the *Secret*, enter in your Real ID License Key. You can find your License Key in the [Real ID dashboard](https://dashboard.getverdict.com), or within the Real ID plugin under the **Billing** section in the **Settings**.
6. For the *API Version*, select `WP REST API Integration v3`.
Then finally, click **Save** to create the webhook. You should see the webhook created with a success message.
Now on future orders, WooCommerce will automatically Real ID on new orders.
### Troubleshooting
If you see a `404` error when creating the webhook, make sure you have entered in the URL `https://real-id.getverdict.com/api/webhooks/wc/direct/orders` for the *Delivery URL* field.
If you see a `401` error, please make sure you're using the correct Real ID license key for the store you're setting this webhook.
If you see a or `405` or `500` error, [please contact us for support](https://getverdict.com/contact).
## Allowlisting Real ID's IP address
Real ID doesn't only receive order notifications from your store — it also sends requests **back** to your store to keep ID check results in sync. When a check completes, Real ID calls your store's WordPress REST API (`/wp-json/real-id/v1/webhooks/metadata`) to update the matching order and customer with their verification status.
Many managed WordPress hosts and security plugins protect that REST API with a firewall or bot challenge. If yours blocks these requests, order and customer statuses will stop updating and you may see repeated sync failures.
To prevent this, add Real ID's dedicated IP address to your host's allowlist:
```
100.51.45.70
```
Every request Real ID makes to your store comes from this single, static address.
:::tip SiteGround
SiteGround's anti-bot firewall is a common cause of blocked syncs. In **Site Tools → Security**, add `100.51.45.70` to the allowlist (and, if you use the SiteGround Security plugin, exclude it there too). Other hosts — Cloudflare, Sucuri, Wordfence, Kinsta — offer an equivalent IP allowlist under their firewall or security settings.
:::
If statuses still don't sync after allowlisting the address, [please contact us for support](https://getverdict.com/contact).