Integration guide

Using the Identity Verification (IDV) service, you can enable a face comparison check that can be used to authenticate a user by using their selfie.

This check does an AI comparison between a live user selfie and the reference facial image to return a confidence score. Combined with a liveness check.

Good to know

Face Auth (via a face comparison check) can be requested along with other checks (i.e. Document authenticity, Face match etc.) or as a standalone check.

Install the SDK

The Yoti Client SDK provides several helper methods to interact with the API. You can initialise the client using your unique SDK ID and PEM file.

const path = require('path');

const fs = require('fs');

const { IDVClient } = 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);

import com.yoti.api.client.ClassPathKeySource;

import com.yoti.api.client.docs.DocScanClient;

import com.yoti.api.client.docs.DocScanException;

...

DocScanClient docScanClient = DocScanClient.builder()

.withClientSdkId("YOTI_CLIENT_SDK_ID")

.withKeyPairSource(ClassPathKeySource.fromClasspath("/path/to/pem"))

.build();

...

use Yoti\DocScan\DocScanClient;

$YOTI_CLIENT_SDK_ID = 'YOTI_CLIENT_SDK_ID';

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

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

# Coming Soon

using System.IO;

using System.Net.Http;

using Yoti.Auth;

using Yoti.Auth.DocScan;

...

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());

...

package main

import (

"os"

"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"

)

var (

sdkId string

key []byte

)

func main() {

var err error

sdkId = "YOTI_CLIENT_SDK_ID"

key, err = os.ReadFile("/path/to/pem")

if err != nil {

panic(err)

}

var client *docscan.Client

client, err = docscan.NewClient(sdkId, key)

if err != nil {

panic(err)

}

You can use the createSession method from the above "idvClient" to create a Yoti session. Session specification needs to be passed as an argument. After the session is successfully created, you will get a Session ID that can be used to retrieve the Session configuration.

let sessionId, sessionToken;

idvClient

.createSession(sessionSpec)

.then((session) => {

sessionId = session.getSessionId();

sessionToken = session.getClientSessionToken();

})

.catch((err) => {

console.log(err)

});

const sessionConfig = await idvClient.getSessionConfiguration(sessionId);

import com.yoti.api.client.docs.session.create.CreateSessionResult;

import com.yoti.api.client.docs.session.retrieve.configuration.SessionConfigurationResponse;

...

CreateSessionResult session = docScanClient.createSession(sessionSpec);

String sessionId = session.getSessionId();

String sessionToken = session.getClientSessionToken();

SessionConfigurationResponse sessionConfig = docScanClient.getSessionConfiguration(sessionId);

...

$session = $client->createSession($sessionSpec);

$sessionId = $session->getSessionId();

$sessionToken = $session->getClientSessionToken();

$sessionConfig = $client->getSessionConfiguration($sessionId);

# Coming Soon

using Yoti.Auth.DocScan.Session.Retrieve.Configuration

...

CreateSessionResult session = docScanClient.CreateSession(sessionSpec);

string sessionId = session.SessionId;

string sessionToken = session.ClientSessionToken

SessionConfigurationResponse sessionConfig = docScanClient.GetSessionConfiguration(sessionId);

...

var createSessionResult *create.SessionResult

createSessionResult, err = client.CreateSession(sessionSpec)

if err != nil {

panic(err)

}

sessionId := createSessionResult.SessionID

clientSessionToken := createSessionResult.ClientSessionToken

sessionConfig, err := client.GetSessionConfiguration(sessionId)

if err != nil {

panic(err)

}

Configure a session

To use this service, you need to create an Identity Verification session specification with at least two checks - Liveness and Face Comparison. Face Comparison check is only available as an automated check.

const {

SessionSpecificationBuilder,

RequestedLivenessCheckBuilder,

RequestedFaceComparisonCheckBuilder,

SdkConfigBuilder

} = require('yoti');

// Liveness check with 3 retries

const livenessCheck = new RequestedLivenessCheckBuilder()

.forStaticLiveness()

.withMaxRetries(3)

.build();

// Face Auth (face comparison check) with manual check set to never

const faceComparisonCheck = new RequestedFaceComparisonCheckBuilder()

.withManualCheckNever()

.build();

// Configuration for the client SDK (Frontend)

const sdkConfig = new SdkConfigBuilder()

.withSuccessUrl('/success')

.withErrorUrl('/error')

.withAllowHandoff(true)

.build();

// Buiding the Session with defined specification from above

import com.yoti.api.client.docs.session.create.check.RequestedLivenessCheck;

import com.yoti.api.client.docs.session.create.check.RequestedFaceComparisonCheck;

import com.yoti.api.client.docs.session.create.SdkConfig;

import com.yoti.api.client.docs.session.create.SessionSpec;

...

SessionSpec sessionSpec = SessionSpec.builder()

.withClientSessionTokenTtl(600)

.withResourcesTtl(90000)

.withUserTrackingId("some-user-tracking-id")

.withRequestedCheck(

RequestedLivenessCheck.builder()

.forStaticLiveness()

.withMaxRetries(3)

.build()

)

.withRequestedCheck(

RequestedFaceComparisonCheck.builder()

.withManualCheckNever()

.build()

)

use Yoti\DocScan\Session\Create\Check\RequestedLivenessCheckBuilder;

use Yoti\DocScan\Session\Create\Check\RequestedFaceComparisonCheckBuilder;

use Yoti\DocScan\Session\Create\SdkConfigBuilder;

use Yoti\DocScan\Session\Create\SessionSpecificationBuilder;

$sessionSpec = (new SessionSpecificationBuilder())

->withClientSessionTokenTtl(600)

->withResourcesTtl(90000)

->withUserTrackingId('some-user-tracking-id')

->withRequestedCheck(

(new RequestedLivenessCheckBuilder())

->forLivenessType('Static')

->withMaxRetries(3)

->build()

)

->withRequestedCheck(

(new RequestedFaceComparisonCheckBuilder())

->withManualCheckNever()

->build()

)

->withSdkConfig(

# Coming Soon

using Yoti.Auth;

using Yoti.Auth.DocScan;

using Yoti.Auth.DocScan.Session.Create;

using Yoti.Auth.DocScan.Session.Create.Check;

...

var sessionSpec = new SessionSpecificationBuilder()

.WithClientSessionTokenTtl(600)

.WithResourcesTtl(90000)

.WithUserTrackingId("some-user-tracking-id")

.WithRequestedCheck(

new RequestedLivenessCheckBuilder()

.ForStaticLiveness()

.Build()

)

.WithRequestedCheck(

new RequestedFaceComparisonCheckBuilder()

.WithManualCheckNever()

.Build()

)

.WithSdkConfig(

new SdkConfigBuilder()

.WithSuccessUrl(Path.Combine("/success"))

.WithErrorUrl(Path.Combine("/error"))

package main

import (

"os"

"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"

)

func buildSessionSpec() (sessionSpec *create.SessionSpecification, err error) {

var livenessCheck *check.RequestedLivenessCheck

livenessCheck, err = check.NewRequestedLivenessCheckBuilder().

ForStaticLiveness().

WithMaxRetries(3).

Build()

if err != nil {

panic(err)

}

var faceComparisonCheck *check.RequestedFaceComparisonCheck

faceComparisonCheck, err = check.NewRequestedFaceComparisonCheckBuilder().

WithManualCheckNever().

{

"client_session_token_ttl": 600,

"resources_ttl": 90000,

"user_tracking_id": "some-user-tracking-id",

"requested_checks": [

{

"type": "LIVENESS",

"config": {

"liveness_type": "STATIC",

"max_retries": 3

}

{

"type": "FACE_COMPARISON",

"config": {

"manual_check": "NEVER"

}

"requested_tasks": [],

"sdk_config": {

"locale": "en-US",

"preset_issuing_country": "GBR",

"success_url": "/success",

"error_url": "/error",

"allow_handoff": true

Create a Face Capture resource

Before uploading the user's facial image, you have to create a Face capture resource. To do this, a Requirement ID from the Face Capture requirements needs to be retrieved from the session config. This can then be used to create a Face Capture resource. If successful, you will receive a Resource ID.

const {

CreateFaceCaptureResourcePayloadBuilder,

UploadFaceCaptureImagePayloadBuilder,

} = require('yoti');

const resourceRequirements = sessionConfiguration.getCapture().getFaceCaptureResourceRequirements()[0];

const requirementId = resourceRequirements.getId();

const faceCapturePayload = new CreateFaceCaptureResourcePayloadBuilder()

.withRequirementId(requirementId)

.build();

const faceCaptureResource = await idvClient.createFaceCaptureResource(sessionId, faceCapturePayload);

const resourceId = faceCaptureResource.getId();

import com.yoti.api.client.docs.session.retrieve.configuration.SessionConfigurationResponse;

import com.yoti.api.client.docs.session.retrieve.configuration.capture;

import com.yoti.api.client.docs.session.retrieve.configuration.capture.facecapture;

import com.yoti.api.client.docs.session.create.facecapture.CreateFaceCaptureResourcePayload;

import com.yoti.api.client.docs.session.retrieve.CreateFaceCaptureResourceResponse;

...

RequiredFaceCaptureResourceResponse resourceRequirements = sessionConfig.getCapture().getFaceCaptureResourceRequirements().get(0);

String requirementId = resourceRequirements.getId();

CreateFaceCaptureResourcePayload faceCapturePayload = CreateFaceCaptureResourcePayload.builder()

.withRequirementId(requirementId)

.build();

CreateFaceCaptureResourceResponse faceCaptureResource = docScanClient.createFaceCaptureResource(sessionId, faceCapturePayload);

use Yoti\DocScan\Session\Retrieve\Configuration;

use Yoti\DocScan\Session\Retrieve\Configuration\Capture;

use Yoti\DocScan\Session\Retrieve\Configuration\Capture\CaptureResponse;

use Yoti\DocScan\Session\Create\FaceCapture;

use Yoti\DocScan\Session\Create\FaceCapture\CreateFaceCaptureResourcePayloadBuilder;

use Yoti\DocScan\Session\Retrieve\CreateFaceCaptureResourceResponse;

$resourceRequirements = $sessionConfig->getCapture()->getFaceCaptureResourceRequirements()[0];

$requirementId = $resourceRequirements->getId();

$faceCapturePayload = (new CreateFaceCaptureResourcePayloadBuilder())

->withRequirementId($requirementId)

->build();

$faceCaptureResource = $client->createFaceCaptureResource($sessionId, $faceCapturePayload);

$resourceId = $faceCaptureResource->getId();

# Coming Soon

using Yoti.Auth.DocScan.Session.Create.FaceCapture

using Yoti.Auth.DocScan.Session.Create.FaceCapture.CreateFaceCaptureResourcePayloadBuilder

using Yoti.Auth.DocScan.Session.Retrieve.Configuration.Capture

...

RequiredFaceCaptureResourceResponse resourceRequirements = sessionConfiguration.Capture.GetFaceCaptureResourceRequirements()[0];

string requirementId = resourceRequirements.Id;

CreateFaceCaptureResourcePayload faceCapturePayload = new CreateFaceCaptureResourcePayloadBuilder()

.WithRequirementId(requirementId)

.Build();

CreateFaceCaptureResourceResponse faceCaptureResource = docScanClient.CreateFaceCaptureResource(sessionId, faceCapturePayload);

string resourceId = faceCaptureResource.Id;

...

import (

"os"

"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/facecapture"

)

func main() {

var err error

resourceRequirements := sessionConfig.GetCapture().GetFaceCaptureResourceRequirements()[0]

requirementId := resourceRequirements.GetID()

faceCapturePayload := facecapture.NewCreateFaceCaptureResourcePayload(requirementId)

faceCaptureResource, err := client.CreateFaceCaptureResource(sessionId, faceCapturePayload)

if err != nil {

panic(err)

}

resourceId := faceCaptureResource.GetID()

_ = resourceId // Use resourceId as needed

Upload a facial image

To perform accurate face authentication, a user's facial image is required. You have to get the contents of this image, which can then be uploaded using the Yoti Client. You also have to pass in the Resource ID retrieved earlier.

const fs = require('fs');

const imageBuffer = fs.readFileSync('path-to-selfie-jpeg');

const faceCaptureImagePayload = new UploadFaceCaptureImagePayloadBuilder()

.forJpegImage()

.withImageContents(imageBuffer)

.build();

await idvClient.uploadFaceCaptureImage(sessionId, resourceId, faceCaptureImagePayload);

import javax.imageio.ImageIO;

import java.awt.image.BufferedImage;

import java.io.ByteArrayOutputStream;

import com.yoti.api.client.docs.session.create.facecapture.UploadFaceCaptureImagePayload;

...

BufferedImage imageBuffer = ImageIO.read(new File("path-to-selfie-jpeg"));

ByteArrayOutputStream bos = new ByteArrayOutputStream();

ImageIO.write(bImage, "jpg", bos);

byte[] data = bos.toByteArray();

UploadFaceCaptureImagePayload faceCaptureImagePayload = UploadFaceCaptureImagePayload.builder()

.forJpegImage()

.withImageContents(data)

.build();

docScanClient.uploadFaceCaptureImage(sessionId, resourceId, faceCaptureImagePayload);

...

use Yoti\Media\Image\Jpeg;

use Yoti\DocScan\Session\Create\FaceCapture\UploadFaceCaptureImagePayloadBuilder;

$imageData = file_get_contents('path-to-selfie-jpeg');

$faceCaptureImagePayload = (new UploadFaceCaptureImagePayloadBuilder())

->forJpegImage()

->withImageContents($imageData)

->build();

$client->uploadFaceCaptureImage($sessionId, $resourceId, $faceCaptureImagePayload);

# Coming Soon

using System.IO;

using Yoti.Auth.DocScan.Session.Create.FaceCapture

using Yoti.Auth.DocScan.Session.Create.FaceCapture.UploadFaceCaptureImagePayloadBuilder

...

string imagePath = "path-to-selfie-jpeg";

byte[] imageData = File.ReadAllBytes(imagePath);

UploadFaceCaptureImagePayload faceCaptureImagePayload = new UploadFaceCaptureImagePayloadBuilder()

.ForJpegImage()

.WithImageContents(imageData)

.Build();

docScanClient.UploadFaceCaptureImage(sessionId, resourceId, faceCaptureImagePayload);

...

import (

"encoding/base64"

"os"

"github.com/getyoti/yoti-go-sdk/v3/docscan/session/create/facecapture"

)

func main() {

imgBytes, err := os.ReadFile("face.png")

if err != nil {

panic(err)

}

base64Str := base64.StdEncoding.EncodeToString(imgBytes)

}

addResource := client.AddFaceCaptureResourceToSession(sessionId, base64Str)

Launch the User Interface

The next step is to load the Yoti Client SDK. To do this, you need the following parameters generated with the session creation request above:

Session ID
Session Token

We then utilise these to construct a Web URL which loads the Yoti Client SDK. The URL is in the following format:

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

Once the URL above opens in a web browser, it will take the user through the liveness capture flow. For more detailed steps, please refer to Launch the user view page.

Retrieve results

Once a session has been completed, the associated checks' results and resources can be retrieved using the session ID. Each check would contain a recommendation and a breakdown. The resources, however, are not directly included in the results, but contain a media ID. This can be used to fetch the actual media resource.

The user may have attempted liveness multiple times; the liveness results may contain multiple images, as a liveness result is generated for each allowed retry.

For a face comparison to be considered a 'PASS' overall, at least one Liveness check should be 'APPROVE', and the Face Comparison check is also 'APPROVE'.

Retrieve checks

idvClient.getSession(sessionId).then(sessionResult => {

const state = sessionResult.getState();

const livenessChecks = sessionResult.getLivenessChecks();

livenessChecks.map(check => {

const id = check.getId();

const state = check.getState();

const resourcesUsed = check.getResourcesUsed();

const report = check.getReport();

const recommendation = report.getRecommendation().getValue();

const breakdown = report.getBreakdown();

breakdown.forEach(function(breakdown) {

const subCheck = breakdown.getSubCheck();

const subCheckResult = breakdown.getResult();

});

})

const faceComparisonChecks = sessionResult.getFaceComparisonChecks();

GetSessionResult sessionResult = docScanClient.getSession(sessionId);

String state = sessionResult.getState();

List<? extends CheckResponse> livenessChecks = sessionResult.getLivenessChecks();

for (CheckResponse check: livenessChecks) {

String id = check.getId();

String state = check.getState();

List<String> resourcesUsed = check.getResourcesUsed();

ReportResponse report = check.getReport();

String recommendation = report.getRecommendation().getValue();

List<? extends BreakdownResponse> breakdown = report.getBreakdown();

for (BreakdownResponse breakdown: breakdown) {

String subCheck = breakdown.getSubCheck();

String subCheckResult = breakdown.getResult();

}

List<? extends CheckResponse> faceComparisonChecks = sessionResult.getFaceComparisonChecks();

$sessionResult = $docScanClient->getSession($sessionId);

$state = $sessionResult->getState();

$livenessChecks = $sessionResult->getLivenessChecks();

foreach($livenessChecks as $check) {

$id = $check->getId();

$state = $check->getState();

$resourcesUsed = $check->getResourcesUsed();

$report = $check->getReport();

$recommendation = $report->getRecommendation()->getValue();

$breakdown = $report->getBreakdown();

foreach($breakdown as $breakdown) {

$subCheck = $breakdown->getSubCheck();

$subCheckResult = $breakdown->getResult();

}

$faceComparisonChecks = $sessionResult->getFaceComparisonChecks();

foreach($faceComparisonChecks as $check) {

$id = $check->getId();

# Coming Soon

GetSessionResult sessionResult = docScanClient.GetSession(sessionId);

string state = sessionResult.State;

List<CheckResponse> livenessChecks = sessionResult.GetLivenessChecks();

foreach (CheckResponse check in livenessChecks)

{

string id = check.Id;

string state = check.State;

List<String> resourcesUsed = check.ResourcesUsed;

ReportResponse report = check.Report;

string recommendation = report.Recommendation.Value;

List<BreakdownResponse> breakdown = report.Breakdown;

foreach (BreakdownResponse breakdown in breakdown)

{

string subCheck = breakdown.SubCheck;

string subCheckResult = breakdown.Result;

}

var sessionResults *retrieve.GetSessionResult

sessionResults, err = client.GetSession(sessionId)

if err != nil {

panic(err)

}

state := sessionResults.State

livenessChecks := sessionResults.LivenessChecks()

for _, check := range livenessChecks {

id := check.GetID()

state := check.GetState()

resourcesUsed := check.GetResourcesUsed()

report := check.GetReport()

recommendation := report.GetRecommendation().GetValue()

breakdown := report.GetBreakdown()

for _, breakdown := range breakdown {

subCheck := breakdown.GetSubCheck()

subCheckResult := breakdown.GetResult()

}

faceComparisonChecks := sessionResults.FaceComparisonChecks()

for _, check := range faceComparisonChecks {

Example response

{

"client_session_token_ttl": 569,

"session_id": "5e0839fd-c853-1234-56a2-e78910b223ce",

"state": "COMPLETED",

"checks": [

{

"type": "LIVENESS",

"id": "346e9c19-594c-43c0-86a0-372b0d0541ed",

"state": "DONE",

"resources_used": [

"148612b8-dfbd-48f8-ba84-bc5053a23763"

"generated_media": [],

"report": {

"recommendation": {

"value": "APPROVE"

"breakdown": [

{

"sub_check": "face_processing",

"result": "PASS",

"details": [],

"process": "AUTOMATED"

The result of the face comparison check is under the FACE_COMPARISON check's report attribute. The following are examples of the report object for a match and a no-match result.

{

"report": {

"recommendation": {

"value": "APPROVE"

"breakdown": [

{

"sub_check": "ai_face_match",

"result": "PASS",

"details": [

{

"name": "confidence_score",

"value": "0.99"

}

"process": "AUTOMATED"

}

]

}

{

"report": {

"recommendation": {

"value": "REJECT",

"reason": "NO_MATCH"

"breakdown": [

{

"sub_check": "ai_face_match",

"result": "FAIL",

"details": [

{

"name": "confidence_score",

"value": "0.00"

}

"process": "AUTOMATED"

}

]

}

It is essential to comprehensively understand our sub checks and thoroughly examine all the results obtained from these checks. For more details about what each report shows, please refer to Session results.

Retrieve resources

To get the images of the user, you will need to retrieve a resource ID, which will then be used to retrieve the media (below).

idvClient.getSession(sessionId).then(sessionResult => {

const resources = sessionResult.getResources();

const faceCaptureResources = resources.getFaceCaptureResources();

const staticLivenessResources = resources.getStaticLivenessResources();

staticLivenessResources.map(resource => {

const id = resource.getId();m

const type = resource.getLivenessType();

const mediaId = check.getImage().getId();

})

}).catch(error => {

console.log(error);

// handle error

})

GetSessionResult sessionResult = docScanClient.getSession(sessionId);

ResourceContainer resources = sessionResult.getResources();

List<? extends FaceCaptureResourceResponse> faceCaptureResources = resources.getFaceCapture();

List<? extends StaticLivenessResourceResponse> staticLivenessResources = resources.getStaticLivenessResources();

for (StaticLivenessResourceResponse resource: staticLivenessResources) {

String id = resource.getId();

String type = resource.getLivenessType();

String mediaId = resource.getImage().getMedia().getId();

}

$sessionResult = $docScanClient->getSession($sessionId);

$resources = $sessionResult->getResources();

$faceCaptureResources = $resources->getFaceCapture();

$staticLivenessResources = $resources->getStaticLivenessResources();

foreach ($staticLivenessResources as $resource) {

$id = $resource->getId();

$type = $resource->getLivenessType();

$mediaId = $resource->getImage()->getId();

}

# Coming Soon

GetSessionResult sessionResult = docScanClient.GetSession(sessionId);

ResourceContainer resources = sessionResult.Resources;

List<FaceCaptureResourceResponse> faceCaptureResources = resources.FaceCapture;

List<StaticLivenessResourceResponse> staticLivenessResources = resources.StaticLivenessResources;

foreach (StaticLivenessResourceResponse resource in staticLivenessResources)

{

string id = resource.Id;

string type = resource.LivenessType;

string mediaId = resource.image.Media.Id;

}

resources := sessionResults.GetResources()

faceCaptureResources := resources.GetFaceCaptureResources()

staticLivenessResources := resources.GetStaticLivenessResources()

for _, resource := range staticLivenessResources {

id := resource.GetID()

livenessType := resource.GetLivenessType()

mediaId := resource.GetImage().GetID()

}

"resources": {

"liveness_capture": [

{

"id": "321c5432-79e2-4f74-8b99-000001bb10d4d",

"tasks": [],

"source": {

"type": "END_USER"

"created_at": "2026-05-18T10:51:47Z",

"last_updated": "2026-05-18T10:52:34Z",

"image": {

"media": {

"id": "4815324fb-4a0a-442a-ba72-9074c6b81234",

"type": "IMAGE",

"created": "2026-05-18T10:52:34Z",

"last_updated": "2026-05-18T10:52:34Z"

}

"capture_type": "MULTI_FRAME",

"liveness_type": "STATIC"

}

"face_capture": [

{

"id": "133e24fe-a65c-4fdc-8fc7-102938475647",

"tasks": [],

Retrieve media

This is to retrieve the images from the session.

idvClient.getMediaContent(sessionId, mediaId).then(media => {

const buffer = media.getContent();

const mimeType = media.getMimeType();

const base64Content = media.getBase64Content();

// handle base64content or buffer

}).catch(error => {

console.log(error)

// handle error

})

Media media = docScanClient.getMediaContent(sessionId, mediaId);

$media = $docScanClient->getMediaContent($sessionId, $mediaId);

$mimeType = $media->getMimeType();

$base64Content = $media->getBase64Content();

# Coming Soon

MediaValue media = docScanClient.GetMediaContent(sessionId, pageMediaId);

string mimeType = media->GetMIMEType();

string base64Content = $media->GetBase64URI();

media, err := client.GetMediaContent(sessionId, mediaID)

if err != nil {

panic(err)

}

mimeType := media.MIME()

content := media.Data()

base64URL := media.Base64URL()

Last updated on

Was this page helpful?