Quick Start

We suggest you read through the step-by-step integration guide to understand the integration in detail. Please see below for a quick start example and example projects.

Before you start

You will need to sign in to your Yoti Hub account using your email and password or the Yoti mobile app, and ensure your business is verified with Yoti.

Onboarding with Yoti

Below is an example complete request snippet in different languages.

Install the SDK

npm install -S -E yoti
// If you are using Maven, add the following dependency:
<dependency>
<groupId>com.yoti</groupId>
<artifactId>yoti-sdk-api</artifactId>
<version>4.4.0</version>
</dependency>

// If you are using Gradle, add the following dependency:
implementation group: 'com.yoti', name: 'yoti-sdk-api', version: '4.4.0'
// Get the Yoti PHP SDK library via a Composer package
composer require yoti/yoti-php-sdk
pip install yoti
// 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
// Simply add this as an import:
import "github.com/getyoti/yoti-go-sdk/v3"

// Or add the following line to your go.mod file
require github.com/getyoti/yoti-go-sdk/v3

// Or you can run the following command in your terminal:
go get github.com/getyoti/yoti-go-sdk/v3

Create a session

This is an example showing:

  • One document authenticity check

  • Text extraction

  • Liveness

  • Face match.

const path = require('path');
const fs = require('fs');

const {
IDVClient,
SessionSpecificationBuilder,
RequestedDocumentAuthenticityCheckBuilder,
RequestedLivenessCheckBuilder,
RequestedTextExtractionTaskBuilder,
RequestedFaceMatchCheckBuilder,
SdkConfigBuilder

} = require('yoti');

const YOTI_CLIENT_SDK_ID = 'YOTI_CLIENT_SDK_ID';
const YOTI_PEM = fs.readFileSync(path.join(__dirname, '/path/to/pem'));
const idvClient = new IDVClient(YOTI_CLIENT_SDK_ID, YOTI_PEM);

// Document Authenticity Check
const documentAuthenticityCheck = new RequestedDocumentAuthenticityCheckBuilder()
.withManualCheckFallback()
.build();

// Liveness check with 3 retries
const livenessCheck = new RequestedLivenessCheckBuilder()
import com.yoti.api.client.ClassPathKeySource;
import com.yoti.api.client.docs.DocScanClient;
import com.yoti.api.client.docs.DocScanException;
import com.yoti.api.client.docs.session.create.CreateSessionResult;
import com.yoti.api.client.docs.session.create.SdkConfig;
import com.yoti.api.client.docs.session.create.SessionSpec;
import com.yoti.api.client.docs.session.create.check.RequestedDocumentAuthenticityCheck;
import com.yoti.api.client.docs.session.create.check.RequestedFaceMatchCheck;
import com.yoti.api.client.docs.session.create.check.RequestedLivenessCheck;
import com.yoti.api.client.docs.session.create.task.RequestedIdDocTextExtractionTask;

...
DocScanClient docScanClient = DocScanClient.builder()
.withClientSdkId("YOTI_CLIENT_SDK_ID")
.withKeyPairSource(ClassPathKeySource.fromClasspath("/path/to/pem"))
<?php

require_once './vendor/autoload.php';

use Yoti\DocScan\DocScanClient;
use Yoti\DocScan\Session\Create\Check\RequestedDocumentAuthenticityCheckBuilder;
use Yoti\DocScan\Session\Create\Check\RequestedFaceMatchCheckBuilder;
use Yoti\DocScan\Session\Create\Check\RequestedLivenessCheckBuilder;
use Yoti\DocScan\Session\Create\SdkConfigBuilder;
use Yoti\DocScan\Session\Create\SessionSpecificationBuilder;
use Yoti\DocScan\Session\Create\Task\RequestedTextExtractionTaskBuilder;
use Yoti\DocScan\Session\Create\NotificationConfigBuilder;

$YOTI_CLIENT_SDK_ID = 'YOTI_CLIENT_SDK_ID';
$YOTI_PEM = '/path/to/pem';

$client = new DocScanClient($YOTI_CLIENT_SDK_ID, $YOTI_PEM);

$sessionSpec = (new SessionSpecificationBuilder())
->withClientSessionTokenTtl(900)
from yoti_python_sdk.doc_scan import (
DocScanClient,
RequestedDocumentAuthenticityCheckBuilder,
RequestedFaceMatchCheckBuilder,
RequestedLivenessCheckBuilder,
RequestedTextExtractionTaskBuilder,
SdkConfigBuilder,
SessionSpecBuilder,
NotificationConfigBuilder
)

YOTI_CLIENT_SDK_ID = 'YOTI_CLIENT_SDK_ID'
YOTI_PEM = '/path/to/pem'

doc_scan_client = DocScanClient(YOTI_CLIENT_SDK_ID, YOTI_PEM)

sdk_config = (
SdkConfigBuilder()
.with_primary_colour("#2d9fff")
.with_preset_issuing_country("GBR")
.with_success_url("/your/success/url")
.with_error_url("/your/error/url")
.build()
)

notification_config = (
NotificationConfigBuilder()
using System.IO;
using System.Net.Http;
using Yoti.Auth;
using Yoti.Auth.DocScan;
using Yoti.Auth.DocScan.Session.Create;
using Yoti.Auth.DocScan.Session.Create.Check;
using Yoti.Auth.DocScan.Session.Create.Task;

...
const string YOTI_CLIENT_SDK_ID = "YOTI_CLIENT_SDK_ID";
const string PEM_PATH = "/path/to/pem";

StreamReader privateKeyStream = System.IO.File.OpenText(PEM_PATH);
var key = CryptoEngine.LoadRsaKey(privateKeyStream);

var docScanClient = new DocScanClient(YOTI_CLIENT_SDK_ID, key, new HttpClient());

var sessionSpec = new SessionSpecificationBuilder()
.WithClientSessionTokenTtl(900)
.WithResourcesTtl(90000)
.WithUserTrackingId("some-user-tracking-id")
.WithRequestedCheck(
package main

import (
"io/ioutil"

"github.com/getyoti/yoti-go-sdk/v3/docscan"
"github.com/getyoti/yoti-go-sdk/v3/docscan/session/create"
"github.com/getyoti/yoti-go-sdk/v3/docscan/session/create/check"
"github.com/getyoti/yoti-go-sdk/v3/docscan/session/create/filter"
"github.com/getyoti/yoti-go-sdk/v3/docscan/session/create/objective"
"github.com/getyoti/yoti-go-sdk/v3/docscan/session/create/task"
)

var (
sdkId string
key []byte
client *docscan.Client
createSessionResult *create.SessionResult
)

func main() {
sdkId := "YOTI_CLIENT_SDK_ID"
key, _ := ioutil.ReadFile("/path/to/pem")

client, err := docscan.NewClient(sdkId, key)
{
"client_session_token_ttl": 900,
"resources_ttl": 90000,
"user_tracking_id": "some-user-tracking-id",
"block_biometric_consent": false,
"requested_checks": [
{
"type": "ID_DOCUMENT_AUTHENTICITY",
"config": {
"manual_check": "FALLBACK"
}
},
{
"type": "LIVENESS",
"config": {
"liveness_type": "STATIC",
"max_retries": 3
}
},
{
"type": "ID_DOCUMENT_FACE_MATCH",
"config": {
"manual_check": "FALLBACK"
}
}
],
"requested_tasks": [

Launch the user interface

The next step is to load the Yoti client SDK. After a session is created a session id and a session token is received, we then use these to construct a URL which loads the Yoti Client SDK:

https://api.yoti.com/idverify/v1/web/index.html?sessionID=<sessionID>&sessionToken=<sessionToken>

Retrieve results

The final step is to retrieve the results of the verification. Session retrieval requires the session ID, that was generated from the create a session endpoint. Below is a basic example of what retrieving a session looks like:

// Returns a session result
idvClient.getSession(sessionId).then(session => {
// Returns the session state
const state = session.getState();
// Returns session resources
const resources = session.getResources();

// Returns all checks on the session
const checks = session.getChecks();

// Return specific check types
const authenticityChecks = session.getAuthenticityChecks();
const faceMatchChecks = session.getFaceMatchChecks();
const textDataChecks = session.getTextDataChecks();
const livenessChecks = session.getLivenessChecks();
const watchlistScreeningChecks = session.getWatchlistScreeningChecks();
const watchlistAdvancedCaChecks = session.getWatchlistAdvancedCaChecks();
// Returns biometric consent timestamp
// Returns a session result
GetSessionResult sessionResult = docScanClient.getSession(sessionId);

// Returns the session state
String state = sessionResult.getState();

// Returns session resources
ResourceContainer resources = sessionResult.getResources();

// Returns all checks on the session
List<? extends CheckResponse> checks = sessionResult.getChecks();

// Return specific check types
List<AuthenticityCheckResponse> authenticityChecks = sessionResult.getAuthenticityChecks();
List<FaceMatchCheckResponse> faceMatchChecks = sessionResult.getFaceMatchChecks();
List<TextDataCheckResponse> textDataChecks = sessionResult.getTextDataChecks();
List<LivenessCheckResponse> livenessChecks = sessionResult.getLivenessChecks();
List<WatchlistScreeningCheckResponse> watchlistScreeningChecks = getSessionResult.getWatchlistScreeningChecks();
<?php
// Returns a session result
$sessionResult = $docScanClient->getSession($sessionId);

// Returns the session state
$state = $sessionResult->getState();

// Returns session resources
$resources = $sessionResult->getResources();

// Returns all checks on the session
$checks = $sessionResult->getChecks();

// Return specific check types
$authenticityChecks = $sessionResult->getAuthenticityChecks();
$faceMatchChecks = $sessionResult->getFaceMatchChecks();
$textDataChecks = $sessionResult->getTextDataChecks();
$livenessChecks = $sessionResult->getLivenessChecks();
$watchlistScreeningChecks = $sessionResult->getWatchlistScreeningChecks();
$watchlistAdvancedCaChecks = $sessionResult->getWatchlistAdvancedCaChecks();

// Returns biometric consent timestamp
# Returns a session result
session_result = doc_scan_client.get_session(session_id)

# Returns the session state
state = session_result.state

# Returns session resources
resources = session_result.resources

# Returns all checks on the session
checks = session_result.checks

# Return specific check types
authenticity_checks = session_result.authenticity_checks
face_match_checks = session_result.face_match_checks
text_data_checks = session_result.text_data_checks
liveness_checks = session_result.liveness_checks

# Returns biometric consent timestamp
biometric_consent = session_result.biometric_consent_timestamp
// Returns a session result
GetSessionResult sessionResult = docScanClient.GetSession(sessionId);

// Returns the session state
string state = sessionResult.State;

// Returns session resources
ResourceContainer resources = sessionResult.Resources;

// Returns all checks on the session
List<CheckResponse> checks = sessionResult.Checks;

// Return specific check types
List<AuthenticityCheckResponse> authenticityChecks = sessionResult.GetAuthenticityChecks();
List<FaceMatchCheckResponse> faceMatchChecks = sessionResult.GetFaceMatchChecks();
List<TextDataCheckResponse> textDataChecks = sessionResult.GetTextDataChecks();
List<LivenessCheckResponse> livenessChecks = sessionResult.GetLivenessChecks();

// Returns biometric consent timestamp
DateTime biometricConsent = sessionResult.BiometricConsentTimestamp();
// Returns a session result
sessionResult, err := client.GetSession(sessionId)

// Returns the session state
state := sessionResult.State

// Returns session resources
resources := sessionResult.Resources

// Returns all checks on the session
checks := sessionResult.Checks

// Return specific check types
authenticityChecks := sessionResult.AuthenticityChecks()
faceMatchChecks := sessionResult.FaceMatchChecks()
textDataChecks := sessionResult.IDDocumentTextDataChecks()
livenessChecks := sessionResult.LivenessChecks()

// Returns biometric consent timestamp
biometricConsent := sessionResult.BiometricConsentTimestamp
{…}

Retrieve media

All data captured in an identity verification session can be fetched. Each data point is linked to a specific media id, the media id is then used in an API call to retrieve it's related media. Below is a basic example of what retrieving media looks like:

idvClient.getMediaContent(sessionId, mediaId).then(media => {
const buffer = media.getContent();
}).catch(error => {
// handle error
})
Media media = docScanClient.getMediaContent(sessionId, mediaId);
<?php
$media = $docScanClient->getMediaContent($sessionId, $mediaId);
media = doc_scan_client.get_media_content(session_id, mediaId)
MediaValue media = docScanClient.GetMediaContent(sessionId, mediaId);
media, err := client.GetMediaContent(sessionId, mediaId)

Delete session and media

It is possible to delete a session or images (media). This can only be done once the session is completed.

Deleting the session will also delete all media from that session. It's also possible to delete a single piece of media. Deleting a media object will delete only that specific object, leaving the rest of the session untouched.

idvClient.deleteSession(sessionId).then(() => {
// Session has been deleted
}).catch(error => {
// Error occured
})

idvClient.deleteMediaContent(sessionId, mediaId).then(() => {
// Media has been deleted
}).catch(error => {
// Error occured
})
docScanClient.deleteSession(sessionId);

docScanClient.deleteMediaContent(sessionId, mediaId);
$docScanClient->deleteSession($sessionId);

$docScanClient->deleteMediaContent($sessionId, $mediaId);
doc_scan_client->delete_session(session_id);

doc_scan_client->delete_media_content(session_id, media_id);
docScanClient.DeleteSession(sessionId);

docScanClient.DeleteMediaContent(sessionId, mediaId);
err = client.DeleteSession(sessionId)

err = client.DeleteMediaContent(sessionId, mediaId)