Introduction

Yoti is an identity checking system that allows organisations to verify who people are, online and in person. For consumers, it’s an app that helps them prove who they are and verify the identities of others.

This document will guide you through the configuration and implementation steps that are necessary in order for your back-end to be able to retrieve a user profile and complete a Yoti share flow. The image below describes the login process and how your back-end integrates with the Yoti architecture.

Login Flow

Yoti provides a set of SDKs that take care of fetching user profiles from our servers. After a user scans your app’s QR code, Yoti provides a one time use token to your back-end. Your back-end can use that token with the SDK to fetch the user profile from the Yoti servers.

The integration process involves five simple steps:

  1. Creating an organisation (only applicable if you are a company)
  2. Creating a Yoti application
  3. Front-end integration
  4. Installing the Yoti SDK
  5. Retrieving a profile

Languages & plugins

If we already support your back-end language, integration is going to be pretty straightforward. We’re working on improving our SDKs all the time! If your preferred language isn’t supported yet, please get in touch: sdksupport@yoti.com and we will do our best to support you!

The languages/platforms that we currently support are:

JavaScript (Node.js): https://github.com/getyoti/yoti-node-sdk

Ruby https://github.com/getyoti/yoti-ruby-sdk

PHP https://github.com/getyoti/yoti-php-sdk

Python https://github.com/getyoti/yoti-python-sdk

Java: https://github.com/getyoti/yoti-java-sdk

Go: https://github.com/getyoti/yoti-go-sdk

.NET: https://github.com/getyoti/yoti-dotnet-sdk

The content management systems (CMS) that we currently support are:

Drupal: https://www.drupal.org/project/yoti

Joomla: https://extensions.joomla.org/extensions/extension/access-a-security/yoti/

WordPress: https://wordpress.org/plugins/yoti/

We’ve included code snippets for each step of the integration process alongside the descriptions.

Integration steps

Let’s get started on integrating Yoti with your site!

First, you will need to have the free Yoti app on your phone. If you haven’t got it already, you can find it on both Google Play and the App Store.

1. Creating an organisation

If you are using Yoti for personal use please skip this section and head to section 2.

Once you have created your Yoti, head over to https://www.yoti.com/dashboard/login-organisations on your desktop computer. To log in, open the Yoti app on your phone, tap Scan Code and scan the QR code displayed on your desktop screen.

Once there, you will need to fill out the form with the following questions:

Your organisation is now created. You will have the ability to add administrators to your organisation. This will allow multiple people to log in to the same organisation dashboard and create applications.

To add administrators:

Once you have completed this we will authorise your organisation and you can proceed to the next step and create a Yoti application.

2. Creating a Yoti application

Once you have created your organisation, the next step is to create an application. Head over to https://www.yoti.com/dashboard on your desktop computer and follow the next steps.

Log in to Dashboard

To log in, open the Yoti app on your phone, tap Scan Code and scan the QR code displayed on your desktop computer.

If you are an organisation please navigate to your organisation page rather than your personal account.

Please note: Once you have logged in to Dashboard, your phone will show a ‘connected’ screen. To keep your data secure, we make sure that only your phone can decipher it. For this reason, you’ll need to keep the Yoti app active whilst you are using Dashboard. If you leave the Yoti app, you will need to log in again.

Creating an application

To create your application, head over to the Applications tab on the side menu. If this is your first time creating an application, you will see a short explanation and a Get started button.

Details tab

Please fill out your details and upload your logo (currently this needs to be in .png format). Your Application name and logo will be shown on the share screen in the Yoti app. Once you have finished filling out your details click the Create button. You will see a notification when this is successful. After completing the details tab, you’ll need to provide information in the other tabs.

Scenarios tab

Scenarios allow you to define different sets of attributes to request from your users, while still using one application. The attributes to request will be defined by the QR code the user scans when they connect to the app. You control the set of attributes to request by specifying a Scenario ID to use at the start of the user journey. Each individual user is uniquely identifiable by their rememberMeId, allowing them to be linked across multiple journeys regardless of the scenario each journey has used.

So a given application will have a single Application ID, Client SDK ID and .pem file, but may use different a Scenario ID for each journey you wish to define.

You will be given your Scenario ID once you activate your app. You will see your Scenario IDs in the scenarios list.

Scenario ID: This is used to associate the button generator with the appropriate scenario that you wish to use.

Keys tab

Contains the various IDs and the key pair for your application.

Application ID: This is required for the Yoti button that you’ll add to your web app’s front end code.

Yoti client SDK ID: You will need this on your back­end to initialise the SDK and it is passed in each call to our servers.

You need to download the PEM file containing your private key in order for your app to connect with Yoti. Just click the Generate key pair button in the keys tab to download it. Please keep this safe as this PEM file is essential to Yoti integration. If you lose or corrupt your PEM file you will be able to generate a new one. Remember, regenerating your key pair will break your current application by invalidating your current PEM file and generated keys. This means you will be unable to decrypt new tokens until these are replaced by the newly-generated ones.

Activating your application

Once you have completed the above steps, you will be able to activate your Yoti application by clicking the activate button in the dropdown menu in the top right.

3. Front-end integration

<head>
  <script src="https://sdk.yoti.com/clients/browser.2.1.0.js"></script>
</head>

<body>
  <!-- This span will create the Yoti button -->
  <span data-yoti-application-id="your-app-id">
    Use Yoti
  </span>

  <!-- This script snippet will also be required in your HTML body -->
  <script>
    _ybg.init()
  </script>
</body>

You will need to provide a button to allow your users to authenticate with Yoti. Upon clicking this button, the user will be redirected to your Yoti application or page, which contains a QR code for them to scan with their Yoti app on their smartphone. Note that mobile web users will skip the QR code scanning step, as they use the Yoti mobile app directly to authenticate.

Yoti provides a button generator for you to use for this purpose. In order to use the button generator, you will need to include the script in your HTML file. In the accompanying example, the button generator script has been added to the head of the html document.

This JavaScript library currently needs to be invoked - do this by calling _ybg.init() in the body of your HTML document. Don’t forget to add an HTML element with the attribute data-yoti-application-id in order for the button to be rendered on the page.

The Yoti button requires the hosting page to be accessed via HTTPS, so please make sure that your web application has HTTPS enabled. Finally, the domain port pair where the button is deployed (for example https://localhost:8000) must match the one that you have configured on the Dashboard. This prevents other web sites from embedding your Yoti button.

 Attribute descriptions

Name Required Options Purpose
data-yoti-application-id true n/a Identifies the Yoti application. This value can be found on your application page in Yoti Dashboard (navigate to Keys -> Application ID).
data-yoti-type false popout, inline, instant How the browser should react when the button is clicked. You can find a description of the options in the table below.
data-yoti-scenario-id false* n/a Used to render the QR code.

* If you set the above to ‘inline’ or ‘instant’ you must set this attribute. This is provided on your application page in Yoti Dashboard (navigate to Keys -> Scenario ID).

Button type options for data-yoti-type

Option Description HTTPS Required
omitted The button will open a Yoti Connect page in the same browser tab. No
“popout” The button will open a Yoti Connect page in a new browser tab. No
“inline” The button will be replaced by an embedded Yoti QR code on click. Yes
“instant” A Yoti QR code is embedded on page load. No button click is required. Yes

4. Installing the Yoti SDK

npm install -S -E yoti
gem install yoti

# The gem provides a configuration generator for Ruby on Rails:

rails generate yoti:install
// Get the Yoti PHP SDK library via a Composer package
composer require yoti/yoti-php-sdk

// Or the following Composer dependency:
"require": {
    "yoti/yoti-php-sdk" : "1.0.*"
}
pip install yoti
// If you are using Maven, add the following dependency:
<dependency>
    <groupId>com.yoti</groupId>
    <artifactId>yoti-sdk-impl</artifactId>
    <version>2.0.0</version>
</dependency>

// If you are using Gradle, add the following dependency:

compile group: 'com.yoti', name: 'yoti-sdk-impl', version: '2.0.0'
go get "github.com/getyoti/yoti-go-sdk"
// To install the Yoti NuGet package you will need to install NuGet.

// To import the latest Yoti SDK into your project, enter the following
// command from NuGet Package Manager Console in Visual Studio:
Install-Package Yoti

// For other installation methods, see https://www.nuget.org/packages/Yoti

Once you have a working button you can move on to installing the SDK.

To successfully integrate you will need the following information about your app from Dashboard:

There are three purposes for this PEM file:

  1. Decrypting the one time use token
  2. Signing your requests to our servers
  3. Decrypting the fetched user profile, so that the profile data can be consumed by your application

The Yoti SDKs are available via popular dependency management systems. Further details can be found on the pages of the specific projects.

Once you have added the Yoti SDK dependency to your project, it’s time to initialise a Yoti client as shown in the code snippet below.

5. Retrieving a Profile

const yoti = require('yoti')
const CLIENT_SDK_ID = 'your-client-sdk-id'
const PEM_PATH = 'path/to/your-application-pem-file.pem'
const PEM_KEY = fs.readFileSync(PEM_PATH)

// For SDK version < 3
const yotiClient = new yoti(CLIENT_SDK_ID, PEM)

// For SDK version >= 3
const yotiClient = new yoti.Client(CLIENT_SDK_ID, PEM_KEY)
Yoti.configuration do |c|
  c.yoti_client_sdk_id = ENV['YOTI_CLIENT_SDK_ID']
  c.yoti_key_file_path = ENV['YOTI_KEY_FILE_PATH']
end

# or

Yoti.configuration do |c|
  c.yoti_client_sdk_id = ENV['YOTI_CLIENT_SDK_ID']
  c.yoti_key = ENV['YOTI_KEY']
end

# Where *YOTI_KEY* is an environment variable that stores the content of the secret key:

# YOTI_KEY="-----BEGIN RSA PRIVATE KEY-----\nMIIEp..."
<?php
require_once './vendor/autoload.php';
$client = new \Yoti\YotiClient('SDK_ID', 'path/to/your-application-pem-file.pem');
from yoti_python_sdk import Client

client = Client(YOTI_CLIENT_SDK_ID, YOTI_KEY_FILE_PATH)
import java.io.File;
import com.yoti.api.client.ActivityDetails;
import com.yoti.api.client.Date;
import com.yoti.api.client.FileKeyPairSource;
import com.yoti.api.client.HumanProfile;
import com.yoti.api.client.HumanProfile.Gender;
import com.yoti.api.client.Image;
import com.yoti.api.client.YotiClient;
import com.yoti.api.client.YotiClientBuilder;

YotiClient client = YotiClientBuilder.newInstance()
    .forApplication(<YOUR_CLIENT_SDK_ID>)
    .withKeyPair(FileKeyPairSource.fromFile(new File("<PATH/TO/YOUR/APPLICATION/KEY_PAIR.pem>")))
    .build();
sdkID := "your-sdk-id";
key, _ := ioutil.ReadFile("path/to/your-application-pem-file.pem")

client := yoti.Client{
    SdkID: sdkID,
    Key: key}
const string SDK_ID = "your-sdk-id";
const string PEM_PATH = "path/to/your-application-pem-file.pem";

var privateKeyStream = System.IO.File.OpenText(PEM_PATH);
var yotiClient = new YotiClient(SDK_ID, privateKeyStream);

Back-end integration centres around receiving a one time use token, decrypting it and using it to get a user profile.

When a user scans a Yoti QR code, Yoti makes a GET request to your callback URL, passing a token as a query string parameter named token.

For an URL set as https://your-callback-url in the Yoti Dashboard, the returned callback URL would look like the following: https://your-callback-url?token=<tokenEncryptedWithYourAppPrivateKey>

You can set and edit the callback URL within your Yoti application under the Integration tab. Yoti will automatically prefix the URL with https://.

When your web application receives a token via the exposed endpoint as a query string parameter, you can easily retrieve the user profile. The user profile object provides a set of attributes corresponding to the user attributes you specified during the creation of your Yoti application on Dashboard.

When you pass the token to Yoti Client object, the SDK does the following:

Profile attributes


yotiClient.getActivityDetails(oneTimeUseToken)
  .then((activityDetails) => {
    const userId = activityDetails.getUserId();
    const base64SelfieUri = activityDetails.getBase64SelfieUri();
    const userProfile = activityDetails.getUserProfile(); // deprecated, use getProfile() instead
    const profile = activityDetails.getProfile();

    const selfieImageData = profile.getSelfie().getValue();
    const fullName = profile.getFullName().getValue();
    const familyName = profile.getFamilyName().getValue();
    const givenNames = profile.getGivenNames().getValue();
    const phoneNumber = profile.getPhoneNumber().getValue();
    const emailAddress = profile.getEmailAddress().getValue();
    const dateOfBirth = profile.getDateOfBirth().getValue();
    const postalAddress = profile.getPostalAddress().getValue();
    const gender = profile.getGender().getValue();
    const nationality = profile.getNationality().getValue();
    const ageVerified = profile.getAgeVerified().getValue();

    // You can retrieve the sources and verifiers for each attribute as follows:
    const givenNamesObj = profile.getGivenNames();
    const givenNamesSources = givenNamesObj.getSources(); // list/array of anchors
    const givenNamesVerifiers = givenNamesObj.getVerifiers(); // list/array of anchors

    // You can also retrieve further properties from these respective anchors in the following way:

    // Retrieving properties of the first anchor
    const value = givenNamesSources[0].getValue(); // string
    const subtype = givenNamesSources[0].getSubType(); // string
    const timestamp = givenNamesSources[0].getSignedTimeStamp().getTimestamp(); // Date object
    const originServerCerts = givenNamesSources[0].getOriginServerCerts(); // list of X509 certificates
  })
yoti_activity_details = Yoti::Client.get_activity_details(yoti_one_time_use_token)

user_id = yoti_activity_details.user_id
base64_selfie_uri = yoti_activity_details.base64_selfie_uri
age_verified = yoti_activity_details.age_verified
profile = yoti_activity_details.profile

selfie_image_data = profile.selfie.value
full_name = profile.full_name.value
given_names = profile.given_names.value
family_name = profile.family_name.value
phone_number = profile.phone_number.value
email_address = profile.email_address.value
date_of_birth = profile.date_of_birth.value
postal_address = profile.postal_address.value
gender = profile.gender.value
nationality = profile.nationality.value

# You can retrieve the sources and verifiers for each attribute as follows:
given_names_obj = profile.given_names
given_names_sources = given_names_obj.sources # list of anchors
given_names_verifiers = given_names_obj.verifiers # list of anchors

# You can also retrieve further properties from these respective anchors in the following way:

# Retrieving properties of the first anchor
value = given_names_sources[0].value # string
sub_type = given_names_sources[0].sub_type # string
time_stamp = given_names_sources[0].signed_time_stamp.time_stamp # DateTime object
origin_server_certs = given_names_sources[0].origin_server_certs # list of X509 certificates
<?php
use Yoti\Helper\ActivityDetailsHelper;

$activityDetails = $client->getActivityDetails($oneTimeUsetoken);
$userId = $activityDetails->getUserId();
$base64SelfieURI = ActivityDetailsHelper::getBase64Selfie($activityDetails);
$profile = $activityDetails->getProfile();

$selfieImageData = $profile->getSelfie()->getValue();
$fullName = $profile->getFullName()->getValue();
$givenNames = $profile->getGivenNames()->getValue();
$familyName = $profile->getFamilyName()->getValue();
$phoneNumber = $profile->getPhoneNumber()->getValue();
$emailAddress = $profile->getEmailAddress()->getValue();
$dateOfBirth = $profile->getDateOfBirth()->getValue();
$postalAddress = $profile->getPostalAddress()->getValue();
$gender = $profile->getGender()->getValue();
$nationality = $profile->getNationality()->getValue();
$isAgeVerified = $profile->getAgeCondition()->getValue();

// You can retrieve the sources and verifiers for each attribute as follows:
$givenNamesObj = $profile->getGivenNames();
$givenNamesSources = $givenNamesObj->getSources(); // list of anchors
$givenNamesVerifiers = $givenNamesObj->getVerifiers(); // list of anchors

// You can also retrieve further properties from these respective anchors in the following way:

// Retrieving properties of the first anchor
$value = $givenNamesSources[0]->getValue(); // string
$subType = $givenNamesSources[0]->getSubType(); // string
$timeStamp = $givenNamesSources[0]->getSignedTimeStamp()->getTimestamp(); // DateTime object
$originServerCerts = $givenNamesSources[0]->getOriginServerCerts(); // list of X509 certificates
activity_details = client.get_activity_details(token)
profile = activity_details.profile

selfie = profile.selfie.value
given_names = profile.given_names.value
family_name = profile.family_name.value
full_name = profile.full_name.value
phone_number = profile.phone_number.value
date_of_birth = profile.date_of_birth.value
postal_address = profile.postal_address.value
gender = profile.gender.value
nationality = profile.nationality.value

remember_me_id = activity_details.user_id
base64_selfie_uri = activity_details.base64_selfie_uri

# You can retrieve the anchors, sources and verifiers for each attribute as follows:
given_names_attribute = profile.given_names

given_names_anchors = given_names_attribute.anchors
given_names_sources = given_names_attribute.sources
given_names_verifiers = given_names_attribute.verifiers

# You can also retrieve further properties from these respective anchors in the following way:
source_anchor = given_names_sources[0]
value = source_anchor.value
sub_type = source_anchor.sub_type
timestamp = source_anchor.signed_timestamp
origin_server_certs = source_anchor.origin_server_certs
  ActivityDetails activityDetails = client.getActivityDetails(yotiOneTimeUseToken);
  HumanProfile profile = activityDetails.getUserProfile();

  String userId = activityDetails.getUserId();
  String base64SelfieUri = activityDetails.getBase64Selfie();
  Image selfieImageData = profile.getSelfie();
  String fullName = profile.getFullName().getValue();
  String givenNames = profile.getGivenNames().getValue();
  String familyName = profile.getFamilyName().getValue();
  String phoneNumber = profile.getPhoneNumber().getValue();
  String emailAddress = profile.getEmailAddress().getValue();
  Date dateOfBirth = profile.getDateOfBirth().getValue();
  String gender = profile.getGender().getValue();
  String address = profile.getPostalAddress().getValue();
  String nationality = profile.getNationality().getValue();
  Boolean isAgeVerified = profile.isAgeVerified();

  // You can retrieve the sources and verifiers for each attribute as follows:
  Attribute<String> givenNamesAttr = profile.getGivenNames();
  List<Anchor> givenNamesSources = givenNamesAttr.getSources();
  List<Anchor> givenNamesVerifiers = givenNamesAttr.getVerifiers();

  // You can also retrieve further properties from these respective anchors in the following way:

  // Retrieving properties of the first anchor
  Anchor firstSourceAnchor = givenNamesSources.get(0);
  String value = firstSourceAnchor.getValue();
  String subType = firstSourceAnchor.getSubType();
  SignedTimestamp signedTimestamp = firstSourceAnchor.getSignedTimestamp();
  List<X509Certificate> originCertificates = firstSourceAnchor.getOriginCertificates(); // list of X509 certificates

import (
    "html/template"
)

profile, _ := client.GetUserProfile(yotiOneTimeUseToken)
userDetails := map[string]interface{}{
    "id":              profile.ID,
    "selfieImageData": profile.Selfie.Data,
    "selfieBase64Uri": template.URL(profile.Selfie.URL()),
    "fullName":        profile.FullName,
    "givenNames":      profile.GivenNames,
    "familyName":      profile.FamilyName,
    "mobileNumber":    profile.MobileNumber,
    "emailAddress":    profile.EmailAddress,
    "dateOfBirth":     profile.DateOfBirth,
    "address":         profile.Address,
    "gender":          profile.Gender,
    "nationality":     profile.Nationality,
    "IsAgeVerified":   profile.IsAgeVerified}
ActivityDetails activityDetails = yotiClient.GetActivityDetails(oneTimeUsetoken);
YotiProfile profile = activityDetails.Profile;

string userId = profile.Id;
Image selfie = profile.Selfie.GetImage();
string selfieURI = profile.Selfie.GetBase64URI();
string fullName = profile.FullName.GetValue();
string givenNames = profile.GivenNames.GetValue();
string familyName = profile.FamilyName.GetValue();
string mobileNumber = profile.MobileNumber.GetValue();
string emailAddress = profile.EmailAddress.GetValue();
DateTime? dateOfBirth = profile.DateOfBirth.GetValue();
bool? ageVerified = profile.AgeVerified.GetValue();
string address = profile.Address.GetValue();
string gender = profile.Gender.GetValue();
string nationality = profile.Nationality.GetValue();

// You can retrieve the anchors, sources and verifiers for each attribute as follows:
using System.Security.Cryptography.X509Certificates;
using Yoti.Auth.Anchors;

List<Anchor> givenNamesAnchors = profile.GivenNames.GetAnchors();
List<Anchor> givenNamesSources = profile.GivenNames.GetSources();
List<Anchor> givenNamesVerifiers = profile.GivenNames.GetVerifiers();

// You can also retrieve further properties from these respective anchors in the following way:
Anchor givenNamesFirstSource = profile.GivenNames.GetSources().First();

AnchorType anchorType = givenNamesFirstAnchor.GetAnchorType();
List<X509Certificate2> originServerCerts = givenNamesFirstAnchor.GetOriginServerCerts();
DateTime signedTimeStamp = givenNamesFirstAnchor.GetSignedTimeStamp().GetTimestamp();
string subType = givenNamesFirstAnchor.GetSubType();
List<string> value = givenNamesFirstAnchor.GetValue();

The profile attributes are central to the SDK and allow you to see and work with the information that your users share with you. Please note that only the attributes you ask for in the Data tab in Yoti Dashboard will be present.

Yoti Dashboard attribute name SDK attribute name
ID Photo selfie
Full Name full_name
Given Name(s) given_names
Family Name family_name
Mobile Number phone_number
Email Address email_address
Age / Date of Birth date_of_birth
Age / Verify Condition age_[over|under]:[1-999]
Address postal_address
Gender gender
Nationality nationality

Errors

The retrieve profile endpoint might return the following error codes:

Code Meaning
400 Bad Request – Any of the described query parameters is missing, or the request is wrongly formatted
401 Unauthorized – We couldn’t verify the request signature or any of the auth headers is missing
404 Not Found – The request is correctly signed but there is no profile for the provided one time use token
500 Internal Server Error – Something went wrong during the transaction, user should log in again

AML integration

let country = 'GBR'
let givenNames = 'Edward Richard George'
let familyName = 'Heath'

let amlAddress = new Yoti.AmlAddress(country);
let amlProfile = new Yoti.AmlProfile(givenNames, familyName, amlAddress);

yotiClient.performAmlCheck(amlProfile).then((amlResult) => {
  console.log(amlResult.isOnPepList);
  console.log(amlResult.isOnFraudList);
  console.log(amlResult.isOnWatchList);

  // Or
  console.log(amlResult);
}).catch((err) => {
  console.error(err);
})
country = 'GBR'
given_names = 'Edward Richard George'
family_name = 'Heath'

aml_address = Yoti::AmlAddress.new(country)
aml_profile = Yoti::AmlProfile.new(given_names, family_name, aml_address)

puts Yoti::Client.aml_check(aml_profile)
<?php
use Yoti\Entity\Country;
use Yoti\Entity\AmlAddress;
use Yoti\Entity\AmlProfile;

$country = new Country('GBR');
$givenNames = 'Edward Richard George';
$familyName = 'Heath';

$amlAddress = new AmlAddress($country);
$amlProfile = new AmlProfile($givenNames, $familyName, $amlAddress);
$amlResult = $yotiClient->performAmlCheck($amlProfile);

var_dump($amlResult->isOnPepList());
var_dump($amlResult->isOnFraudList());
var_dump($amlResult->isOnWatchList());

// Or
echo $amlResult;
from yoti_python_sdk import aml
from yoti_python_sdk import Client

country="GBR"
given_names = "Edward Richard George"
family_name = "Heath"

aml_address = aml.AmlAddress(country)
aml_profile = aml.AmlProfile(given_names, family_name, aml_address)

aml_result = yotiClient.perform_aml_check(aml_profile)

print("AML Result for {0} {1}:".format(given_names, family_name))
print("On PEP list: " + str(aml_result.on_pep_list))
print("On fraud list: " + str(aml_result.on_fraud_list))
print("On watchlist: " + str(aml_result.on_watch_list))
// POJOs for the data to check
AmlAddress amlAddress = new AmlAddressBuilder()
                            .withCountry("GBR")
                            .build();
AmlProfile amlProfile = new AmlProfileBuilder()
                            .withGivenNames("Edward Richard George")
                            .withFamilyName("Heath")
                            .withAddress(amlAddress)
                            .build();
AmlResult amlResult = yotiClient.performAmlCheck(amlProfile);

// Result returned in a POJO
System.out.println(amlResult.isOnFraudList());
System.out.println(amlResult.isOnWatchList());
System.out.println(amlResult.isOnPepList());
givenNames := "Edward Richard George"
familyName := "Heath"

amlAddress := yoti.AmlAddress{
    Country: "GBR"}

amlProfile := yoti.AmlProfile{
    GivenNames: givenNames,
    FamilyName: familyName,
    Address:    amlAddress}

result, err := client.PerformAmlCheck(amlProfile)

log.Printf(
    "AML Result for %s %s:",
    givenNames,
    familyName)
log.Printf(
    "On PEP list: %s",
    strconv.FormatBool(result.OnPEPList))
log.Printf(
    "On Fraud list: %s",
    strconv.FormatBool(result.OnFraudList))
log.Printf(
    "On Watch list: %s",
    strconv.FormatBool(result.OnWatchList))
}
AmlAddress amlAddress = new AmlAddress(
   country: "GBR");

AmlProfile amlProfile = new AmlProfile(
    givenNames: "Edward Richard George",
    familyName: "Heath",
    amlAddress: amlAddress);

AmlResult amlResult = yotiClient.PerformAmlCheck(amlProfile);

bool onPepList = amlResult.IsOnPepList();
bool onFraudList = amlResult.IsOnFraudList();
bool onWatchList = amlResult.IsOnWatchList();

Yoti provides an AML (Anti Money Laundering) check service to allow a deeper KYC process to prevent fraud. This is a chargeable service, so please contact sdksupport@yoti.com for more information.

Yoti will provide a boolean result on the following checks:

To use this functionality you must ensure your application is assigned to your organisation in the Yoti Dashboard - please see here for further information.

For the AML check you will need to provide the following:

Performing an AML check on a person requires their consent. You must ensure you have user consent before using this service.

Mobile

The mobile SDK purpose is to provide 3rd party applications the ability to request attributes from a Yoti profile whilst leveraging the Yoti mobile app.

The image below describes the login process and how your back-end integrates with the Yoti architecture.

Mobile Login Flow

For a detailed explanation please visit our GitHub pages. The SDKs we support for mobile are:

Note: If you want to use Yoti with other mobile application development frameworks, you have to make sure they support receiving a broadcast message from an external native app. The Cordova/Ionic platforms currently don’t have official support for it.

Support

For more information, you can check out our Developer FAQs.

If you have any other questions please do not hesitate to contact sdksupport@yoti.com.

Once we have answered your question we may contact you again to discuss Yoti products and services. If you’d prefer us not to do this, please let us know when you e-mail.