NAV Navbar
Ruby Python Javascript

Overview

Introduction

Welcome to Persona! Here you’ll find comprehensive information for integrating with Persona and our API endpoints. We’ve tried to make this documentation user-friendly and example-filled. If you’re planning to use our API in Production, take a look at our Privacy Policy. The fastest way to get your integration up and running is to use the Embedded flow, which walks through your entire Persona integration step-by-step. You’ll integrate Persona into your site or app and then retrieve the data you need from our REST API.

We're always happy to help with code or other questions you might have! Search our documentation, contact support, or connect with our sales team.

Products

Embedded flow The "embedded flow" is an end-to-end module that seamlessly verifies users inside your web page. It allows users to easily verify themselves without leaving their current experience.
Hosted flow The "hosted flow" is a full window experience that provides a secure, elegant inquiry flow. It is fully hosted by Persona but its branding and theming is fully customizable. Its optimized flow allows users to easily provide the information necessary to verify themselves.
WebView flow The "WebView flow" is an end-to-end module that seamlessly verifies users inside your Android application. It allows users to easily verify themselves is a mobile optimized flow.

Terminology

API keys

To gain access to the Persona API, please contact our sales team. We'll provide you with a sandbox api_key for evaluation of the API. Once you’ve completed the signup process and acknowledged our terms, we’ll provide a live production api_key.

Your API keys carry many privileges, so be sure to keep them secure! Do not share your secret API keys in publicly accessible areas such as GitHub, client-side code, and so forth.

API hosts

The Sandbox environment is unrestricted and all verifications will instantly pass in it. All testing should be done in the Sandbox environment. All activity in the Production environment will be billed. When you’re getting ready to launch into Production, please request Production API access from our sales team. The Production CDN serves static assets for Production applications.

Authentication

Authentication to the API is performed via HTTP Bearer Authentication. Provide your API key as the bearer token value. All API requests must be made over HTTPS. Calls made over plain HTTP will fail. API requests without authentication will also fail.

Protocol (REST)

The Persona API uses POST requests to communicate and HTTP response codes to indicate status and errors. All responses come in standard JSON. The Plaid API is served over HTTPS TLS v1.1+ to ensure data privacy; HTTP and HTTPS with TLS versions below 1.1 are not supported. All requests must include a Content-Type of application/json and the body must be valid JSON.

Browser support

Fully supported Fully supported
Fully supported 11+ supported

Modern mobile browsers are supported, including most iPhone and Android devices. See WebView flow for an example Android application using Persona.

Security

Our security philosophy is defense in depth on top of world-class infrastructure. For more information about our security measures, head to our Security Statement or contact us.

Embedded flow

Integrating with Persona

<script src='https://cdn.withpersona.com/assets/v2/persona.js'></script>
<script>
let inquiryId;
const client = new Persona.Client({
  blueprintId: 'blu_WMmFNiixxX1doLfj5KDi6dQq',
  onLoad: () => client.open(),
  onStart: (id) => { inquiryId = id },
  onSuccess: () => {
    console.log(`Sending finished inquiry ${inquiryId} to backend`);
    fetch(`/server-handler?inquiry-id=${inquiryId}`);
  },
});
</script>

Persona securely collects your user’s personal information from your website running in the user’s browser. Whenever a user enters the flow, we generate an inquiry id unique to the user’s journey. This inquiry id allows you to monitor a user’s progress as they verify their identity. The Persona client accepts the following parameters.

Example prefill parameters

{
  "name-first": "Michael",
  "name-last": "Jackson",
  "birthdate": "1958-08-29",
  "address-street-1": "5225 Figueroa Mountain Road",
  "address-city": "Los Olivos",
  "address-subdivision": "California",
  "address-postal-code": "93441"
}
blueprintId
required
This id corresponds to a pre-set configuration and determines how the flow is customized.
environment
optional
The Persona API environment on which to create inquiries. For sandbox and production, use `sandbox` and `production` respectively.
subject
optional
You can generate and provide a unique id which we will associate with the inquiry. The identifier can be used to monitor user progress in newly created inquiries.
language
optional
Specify a supported language to localize the flow. Language will be inferred from browser settings by default.
prefill
optional
Provide an object to prefill form inputs in the flow. Each attribute in the object is optional.
onStart
required
A function that is called when a user starts the flow. The function should expect a single argument, a string inquiry id that references the in-progress inquiry.
onSuccess
required
A function that is called when a user has successfully verified their identity.
onLoad
optional
A function that is called when the Persona module has finished loading. Calls to open() prior to the onLoad callback will still open the flow, and a loading spinner will be shown.
onExit
optional
A function that is called when a user has specifically exited the flow. The function should expect two arguments, a nullable error object and a metadata object.
onEvent
optional
A function that is called when a user reaches certain points in the inquiry flow. The function should expect two arguments, an eventName string and a metadata object.

To retrieve information about inquiries, see Retrieving inquiries

onSuccess callback

The onSuccess callback is called when a user completes the Persona flow. should take one argument, a metadata object.

onExit callback

The onExit callback is called when a user exits the Persona flow. It takes two arguments, a nullable error object and a metadata object.

onEvent callback

Example metadata, eventName = verification-select

{
  "type": "verification/selfie"
}

Example metadata, eventName = verification-change

{
  "id": "ver_rMkwDnyoZy6b1jDSofjUtL5z",
  "status": "submitted",
}

The onEvent callback is called at certain points in the Persona flow. It takes two arguments, an eventName string and a metadata object.

eventName
String
A string representing the event that has just occurred in the Persona flow.
metadata
Object
An object containing information about the event.

The metadata parameter is always present, though some values may be null. Please note that new event names, metadata keys, or view names may be added without notice.

open() function

Calling open will display the intro page to your user, starting the Persona flow. Once open is called, you will begin receiving events via the onEvent callback.

exit() function

The exit function allows you to programmatically close the Persona flow. Calling exit will trigger the onExit callback.

The exit function takes a single, optional argument, a configuration Object. The configuration options are:

force
boolean
If true, Persona will exit immediately. If false, or the option is not provided, an exit confirmation screen may be presented to the user.

Allowed iframe domains

The embedded flow can only be embedded on domains pre-configured for each blueprint. Restrict your list of domains to prevent your blueprints from being used by third-parties. To modify or update allowed iframe domains, contact us.

Hosted flow

The hosted flow allows users to verify their identity in a fully optimized flow. Persona hosts and manages the entire flow. Whenever a user enters the flow, we generate an inquiry id that is unique to the user’ journey. This inquiry id allows you to monitor a user’s progress as they verify their identity.

Directing to the flow

redirect_to 'https://withpersona.com/verify?blueprint-id=blu_WMmFNiixxX1doLfj5KDi6dQq&redirect-uri=https://withpersona.com&subject=<your-unique-id>'
redirect('https://withpersona.com/verify?blueprint-id=blu_WMmFNiixxX1doLfj5KDi6dQq&redirect-uri=https://withpersona.com&subject=<your-unique-id>')
window.location.assign('https://withpersona.com/verify?blueprint-id=blu_WMmFNiixxX1doLfj5KDi6dQq&redirect-uri=https://withpersona.com&subject=<your-unique-id>');

To start the hosted flow, link a user to /verify on Persona with the appropriate GET parameters. To test the hosted flow in the sandbox, use the sandbox host domain.

Example prefill parameters

prefill['name-first']=Michael&prefill['name-last']=Jackson&prefill['birthdate']=1958-08-29&prefill['address-street-1']=5225 Figueroa Mountain Road&prefill['address-city']=Los Olivos&prefill['address-subdivision']=California&prefill['address-postal-code']=93441
blueprint-id
required
This id corresponds to a pre-set configuration and determines how the flow is customized.
redirect-uri
required
When the user successfully verifies their identity, we redirect back to this URL. The callback should expect a GET parameter named `inquiry-id` that references the completed inquiry.
subject
optional
You can generate and provide a unique id which we will associate with the inquiry. The identifier can be used to monitor user progress in newly created inquiries.
language
optional
Specify a supported language to localize the flow. Language will be inferred from browser settings by default.
prefill
optional
Provide an object to prefill form inputs in the flow. Each attribute in the object is optional.

Success callback

response = HTTP.
  headers('Authorization': "Bearer #{Rails.credentials.persona.fetch(:api_key)}").
  get("https://withpersona.com/api/v1/inquiries/#{params.fetch(:'inquiry-id')}")
inquiry = JSON.parse(response.body)
import requests
response = requests.get(
  'https://withpersona.com/api/v1/inquiries/{}'
    .format(request.GET.get('inquiry-id')),
  headers: { 'Authorization': 'Bearer {}'.format() },
)
inquiry = response.json()
const request = require('request');
request(`https://withpersona.com/api/v1/inquiries/${req.query['inquiry-id']}`, { json: true }, (err, res, body) => {
  inquiry = res;
});

Set the redirect-uri GET parameter to your URL that will process responses from Persona. It should expect a inquiry-id query parameter. It should optionally expect a subject GET parameter if you provided one when starting the flow. For more detail on retrieving inquiries with the inquiry-id, see Retrieving inquiries

redirect-uri
required
When the user successfully verifies their identity, we redirect the user back to this URL. The callback should expect a GET parameter named `inquiry-id` that references the completed inquiry.
subject
optional
You can generate and provide a unique id which we will associate with the inquiry. The identifier can be used to monitor user progress in newly created inquiries.

Event webhook

The event webhook is a URL called whenever the user reaches certain points in the flow. It is specified in the blueprint configuration. The webhook should process inquiry-id, event-name, and metadata GET parameters.

inquiry-id
String
A unique identifier for an inquiry.
subject
String
The nullable identifier generated by you. See redirect instructions for setup and usage.
event-name
String
A string representing the event that has just occurred in the Persona flow.
metadata
Object
An JSON object containing information about the event.

The metadata parameter is always present, though some values may be null. Please note that new event names, metadata keys, or view names may be added without notice.

Exit webhook

The exit webhook is a URL called when the user exits the flow without completing the inquiry. The webhook should process inquiry-id, error, and metadata GET parameters.

inquiry-id
String
A unique identifier for an inquiry.
subject
String
The nullable identifier generated by you. See redirect instructions for setup and usage.
error
String
A nullable string containing an error message if applicable.
metadata
Object
An JSON object containing information about the event.

Allowed redirect urls

The hosted flow can only redirect to URLs pre-configured for each blueprint. Restrict your list of domains to prevent your blueprints from being used by third-parties. To modify or update allowed redirect domains, contact us.

WebView flow

The WebView flow allows users to verify their identity in a fully optimized mobile flow. Persona hosts and manages the entire flow. Whenever a user enters the flow, we generate an inquiry id that is unique to the user’ journey. This inquiry id allows you to monitor a user’s progress as they verify their identity.

Example applications

An example Android application using Persona in a WebView is available at https://github.com/persona-id/persona-android-webview

An example iOS application using Persona in a WebView is available at https://github.com/persona-id/persona-ios-webview

Loading the WebView

iOS code example

class PersonaViewController: UIViewController, WKNavigationDelegate {
  let webView = WKWebView()

  override func viewDidLoad() {
    // load the Persona url
    let url = URL(string: generatePersonaInitializationURL())
    let request = URLRequest(url: url!)

    // ...

    self.view.addSubview(webView)
    webView.load(request)
  }

  // generatePersonaInitializationURL :: create the Persona url with query parameters
  func generatePersonaInitializationURL() -> String {
    let config = [
      "blueprint-id": "blu_PDGZKPEASz266wmRcPbuwjPP",
      "redirect-uri": "https://personademo.com",
      "is-webview": "true",
    ]

    // Build a dictionary with the Persona configuration options
    // See the Persona docs (http://documentation.withpersona.com) for full documentation.
    var components = URLComponents()
    components.scheme = "https"
    // NOTE: Change host to sandbox.withpersona.com for the Sandbox environment
    components.host = "withpersona.com"
    components.path = "/verify"
    components.queryItems = config.map { URLQueryItem(name: $0, value: $1) }
    return components.string!
  }

  // ...
}

To start the hosted flow, create a webview and load /verify on Persona with the appropriate GET parameters. To test the WebView flow in the sandbox, use the sandbox host domain.

is-webview
required
Should be set to true.
blueprint-id
required
This id corresponds to a pre-set configuration and determines how the flow is customized.
redirect-uri
required
When the user successfully verifies their identity, we redirect back to this URL. The callback should expect a GET parameter named inquiry-id that references the completed inquiry.
subject
optional
You can generate and provide a unique id which we will associate with the inquiry. The identifier can be used to monitor user progress in newly created inquiries.

Camera configuration

Android code example

webView.setWebChromeClient(new WebChromeClient() {
  @Override
  public void onPermissionRequest(final PermissionRequest request) {
    Log.d(TAG, "onPermissionRequest");
    runOnUiThread(new Runnable() {
      @TargetApi(Build.VERSION_CODES.LOLLIPOP)
      @Override
      public void run() {
        if(request.getOrigin().toString().equals("https://withpersona.com/")) {
          request.grant(request.getResources());
        } else {
          request.deny();
        }
      }
    });
  }

  @Override
  public boolean onShowFileChooser(
      WebView webView, ValueCallback<Uri[]> newFilePathCallback,
      FileChooserParams fileChooserParams) {
    // Implement a file chooser or camera here
  }
});

On Android, verifications that use the camera require you to override permission granting and implement a file chooser. The manifest file must include camera and audio permissions.

On iOS, the Info.plist file must include camera permissions.

Success URL

Android code example

public boolean shouldOverrideUrlLoading(WebView view, String url) {
  Uri parsedUri = Uri.parse(url);
  if (parsedUri.getAuthority().equals("personademo.com")) {
    HashMap<String, String> personaData = parsePersonaUriData(parsedUri);

    Log.d("Inquiry Id: ", personaData.get("inquiry-id"));
    Log.d("Subject: ", personaData.get("subject"));
  }
}

Swift code example

func webView(_ webView: WKWebView,
              decidePolicyFor navigationAction: WKNavigationAction,
              decisionHandler: @escaping ((WKNavigationActionPolicy) -> Void)) {

    let actionType = navigationAction.request.url?.host;
    let queryParams = getUrlParams(url: navigationAction.request.url!)

    if (actionType == "personademo.com") {
        // User succeeded verification
        print("Inquiry Id: \(queryParams["inquiry-id"]!)");
        print("Subject: \(queryParams["subject"]!)");

        // Do nothing
        // You will likely want to transition the view at this point.
        decisionHandler(.cancel)
    } else {
        // Unknown case - do not override URL loading
        decisionHandler(.allow)
    }
}

The redirect uri is loaded when the user successfully verifies their identity. It is configured in the blueprint. Catch the redirect URI in shouldOverrideUrlLoading.

Event URL

The event webhook is a URL called whenever the user reaches certain points in the flow. It is specified in the blueprint configuration.

Exit URL

The exit webhook is a URL called whenever the user closes the flow without verifying their identity. It is specified in the blueprint configuration.

Retrieving data

We support operations to list, view, and delete inquiries and verifications. Please contact us to get access to the detailed API.

Inquiry GET /api/v1/inquiries
GET /api/v1/inquiries/<inquiry-id> DELETE /api/v1/inquiries/<inquiry-id>
Verification GET /api/v1/verifications/<verification-id>
Report GET /api/v1/reports/<report-id>

GET /api/v1/inquiries

require 'http'
response = HTTP.
  headers('Authorization': "Bearer #{Rails.credentials.persona.fetch(:api_key)}").
  get("https://withpersona.com/api/v1/inquiries")
inquiry = JSON.parse(response.body)
import requests
response = requests.get(
  'https://withpersona.com/api/v1/inquiries',
  headers: { 'Authorization': 'Bearer {}'.format(api_key) },
)
inquiry = response.json()
const request = require('request');
request(
  {
    json: true,
    url: `https://withpersona.com/api/v1/inquiries`,
    headers: { 'Authorization': `Bearer ${apiKey}`}
  },
  (err, res, body) => { inquiry = res; }
);

Example response

{
  "data": [
    {
      "type": "inquiry",
      "id": "inq_RQ4jHMYx8wHMCSjQ2M43jf4r",
      "attributes": {
        "status": "completed",
        "subject": null,
        "created-at": "2019-01-18T18:37:23.000Z",
        "completed-at": "2019-01-18T18:38:43.000Z",
        "expired-at": null
      },
      "relationships": {
        "blueprint": {
          "data": {
            "type": "blueprint",
            "id": "blu_fsDYEbaMiP3AraE5VJkfgZPA"
          }
        },
        "verifications": {
          "data": [
            {
              "type": "verification/phone-number",
              "id": "ver_xw93bRD8EjLp8uqsSA2PoEoC"
            },
            {
              "type": "verification/basic",
              "id": "ver_uRmPFecaKgzjmsWGzAVEhrPY"
            }
          ]
        },
        "reports": {
          "data": [
            {
              "type": "report/profile",
              "id": "rep_i2a3jQQlMSLp38XOnweLQm3z"
            },
            {
              "type": "report/watchlist",
              "id": "rep_Iun32mW34j2lknEFUnqiupNW"
            }
          ]
        }
      }
    }
  ]
}

An inquiry represents one user’s journey through the Persona flow. The index route lists all inquiries associated with your organization via the API key. This aggregates inquiries across all organization blueprints.

Inquiries are created when the user begins to verify their identity. Check for the following statuses determine whether the user has finished the flow.

pending When the server has finished all processing, the report will become ready.
completed When a user has completed the required verifications, their inquiry becomes completed.
expired If a user does not finish the flow, their inquiry expires after 24 hours.

GET /api/v1/inquiries/<inquiry-id>

require 'http'
response = HTTP.
  headers('Authorization': "Bearer #{Rails.credentials.persona.fetch(:api_key)}").
  get("https://withpersona.com/api/v1/inquiries/#{params.fetch(:'inquiry-id')}")
inquiry = JSON.parse(response.body)
import requests
response = requests.get(
  'https://withpersona.com/api/v1/inquiries/{}'
    .format(request.GET.get('inquiry-id')),
  headers: { 'Authorization': 'Bearer {}'.format(api_key) },
)
inquiry = response.json()
const request = require('request');
request(
  {
    json: true,
    url: `https://withpersona.com/api/v1/inquiries/${req.query['inquiry-id']}`,
    headers: { 'Authorization': `Bearer ${apiKey}`}
  },
  (err, res, body) => { inquiry = res; }
);

Example response

{
  "data": {
    "type": "inquiry",
    "id": "inq_RQ4jHMYx8wHMCSjQ2M43jf4r",
    "attributes": {
      "status": "completed",
      "subject": null,
      "created-at": "2019-01-18T18:37:23.000Z",
      "completed-at": "2019-01-18T18:38:43.000Z",
      "expired-at": null
    },
    "relationships": {
      "blueprint": {
        "data": {
          "type": "blueprint",
          "id": "blu_fsDYEbaMiP3AraE5VJkfgZPA"
        }
      },
      "verifications": {
        "data": [
          {
            "type": "verification/phone-number",
            "id": "ver_xw93bRD8EjLp8uqsSA2PoEoC"
          },
          {
            "type": "verification/basic",
            "id": "ver_uRmPFecaKgzjmsWGzAVEhrPY"
          }
        ]
      },
      "reports": {
        "data": [
          {
            "type": "report/profile",
            "id": "rep_i2a3jQQlMSLp38XOnweLQm3z"
          },
          {
            "type": "report/watchlist",
            "id": "rep_Iun32mW34j2lknEFUnqiupNW"
          }
        ]
      }
    }
  }
}

To retrieve a single inquiry, use the inquiry id passed to you from the Persona flow. In the embedded flow, the inquiry id is the first parameter of the onStart callback. In the hosted flow, the inquiry id is a query parameter in the success callback.

DELETE /api/v1/inquiries/<inquiry-id>

require 'http'
response = HTTP.
  headers('Authorization': "Bearer #{Rails.credentials.persona.fetch(:api_key)}").
  delete("https://withpersona.com/api/v1/inquiries/#{params.fetch(:'inquiry-id')}")
inquiry = JSON.parse(response.body)
import requests
response = requests.delete(
  'https://withpersona.com/api/v1/inquiries/{}'
    .format(request.GET.get('inquiry-id')),
  headers: { 'Authorization': 'Bearer {}'.format(api_key) },
)
inquiry = response.json()
const request = require('request');
request.delete(
  {
    json: true,
    url: `https://withpersona.com/api/v1/inquiries/${req.query['inquiry-id']}`,
    headers: { 'Authorization': `Bearer ${apiKey}`}
  },
  (err, res, body) => { inquiry = res; }
);

Example response

{
  "data": {
    "type": "inquiry",
    "id": "inq_RQ4jHMYx8wHMCSjQ2M43jf4r",
    "attributes": {
      "status": "completed",
      "subject": null,
      "created-at": "2019-01-18T18:37:23.000Z",
      "completed-at": "2019-01-18T18:38:43.000Z",
      "expired-at": null
    },
    "relationships": {
      "blueprint": {
        "data": {
          "type": "blueprint",
          "id": "blu_fsDYEbaMiP3AraE5VJkfgZPA"
        }
      },
      "verifications": {
        "data": [
          {
            "type": "verification/phone-number",
            "id": "ver_xw93bRD8EjLp8uqsSA2PoEoC"
          },
          {
            "type": "verification/basic",
            "id": "ver_uRmPFecaKgzjmsWGzAVEhrPY"
          }
        ]
      },
      "reports": {
        "data": [
          {
            "type": "report/profile",
            "id": "rep_i2a3jQQlMSLp38XOnweLQm3z"
          },
          {
            "type": "report/watchlist",
            "id": "rep_Iun32mW34j2lknEFUnqiupNW"
          }
        ]
      }
    }
  }
}

Permanently deletes an inquiry and all associated verifications. It cannot be undone. This endpoint can be used to comply with privacy regulations such as GDPR / CCPA or to enforce data privacy.

GET /api/v1/verifications/<verification-id>

require 'http'
response = HTTP.
  headers('Authorization': "Bearer #{Rails.credentials.persona.fetch(:api_key)}").
  get("https://withpersona.com/api/v1/verifications/#{params.fetch(:'verification-id')}")
verification = JSON.parse(response.body)
import requests
response = requests.get(
  'https://withpersona.com/api/v1/verifications/{}'
    .format(request.GET.get('verification-id')),
  headers: { 'Authorization': 'Bearer {}'.format(api_key) },
)
verification = response.json()
const request = require('request');
request(
  {
    json: true,
    url: `https://withpersona.com/api/v1/verifications/${req.query['verification-id']}`,
    headers: { 'Authorization': `Bearer ${apiKey}`}
  },
  (err, res, body) => { verification = res; }
);

Example phone number verification response

{
  "data": {
    "type": "verification/phone-number",
    "id": "ver_uY5ZGNUFvdJ1TU7KsVRS1RrD",
    "attributes": {
      "status": "passed",
      "created-at": "2019-02-13T20:45:19.000Z",
      "country-code": "US",

      ...
    }
  }
}

Example driver license verification response

{
  "data": {
    "type": "verification/driver-license-barcode",
    "id": "ver_Fi4XSWdgbPXZHxRKYtfT3N3M",
    "attributes": {
      "status": "passed",
      "created-at": "2019-02-10T08:15:26.000Z",
      "country-code": "US",

      ...
    }
  }
}

A verification represents one of multiple checks done by a user. An inquiry contains one or more verifications. The attributes available for any given verification depends on its type. Each inquiry’s relationships field lists the ids of all associated verifications. To authenticate when fetching photo URLs, pass the same Authorization header.

Verifications change statuses as the user progresses through the flow. Check for the following statuses to monitor progress and find completed results.

initiated While a user has is still completing the verification, the status will be pending.
submitted When a user has submitted their information, their verification becomes completed. During this status, the server is verifying their information.
passed Once the server has verified the user’s information, the verification passes.
failed If the server fails to verify the user’s information, the verification fails.

GET /api/v1/reports/<report-id>

require 'http'
response = HTTP.
  headers('Authorization': "Bearer #{Rails.credentials.persona.fetch(:api_key)}").
  get("https://withpersona.com/api/v1/reports/#{params.fetch(:'report-id')}")
report = JSON.parse(response.body)
import requests
response = requests.get(
  'https://withpersona.com/api/v1/reports/{}'
    .format(request.GET.get('report-id')),
  headers: { 'Authorization': 'Bearer {}'.format(api_key) },
)
report = response.json()
const request = require('request');
request(
  {
    json: true,
    url: `https://withpersona.com/api/v1/reports/${req.query['report-id']}`,
    headers: { 'Authorization': `Bearer ${apiKey}`}
  },
  (err, res, body) => { report = res; }
);

Example profile report response

{
  "data": {
    "type": "report/profile",
    "id": "rep_i2a3jQQlMSLp38XOnweLQm3z",
    "attributes": {
      "status": "pending",
      "created-at": "2019-02-13T20:45:19.000Z",
      "country-code": "US",

      ...
    }
  }
}

Example watchlist report response

{
  "data": {
    "type": "report/watchlist",
    "id": "rep_Iun32mW34j2lknEFUnqiupNW",
    "attributes": {
      "status": "ready",
      "created-at": "2019-02-10T08:15:26.000Z",
      "country-code": "US",
      "searched_lists": [...],

      ...
    }
  }
}

A report represents additional information pulled on the verified user. An inquiry can contain many reports. The attributes available for any given report depends on its type. Each inquiry’s relationships field lists the ids of all associated reports.

Reports are created and processed asynchronously when an inquiry completes. Check for the following statuses to determine whether a report is ready.

pending While the server processes the report, the status will be pending.
ready When the server has finished processing the report, the status will be ready.