---
title: "Test verification/KYC scenarios"
description: "Learn how you can test your error handling flows."
url: "https://docs.adyen.com/platforms/test-verification-errors"
source_url: "https://docs.adyen.com/platforms/test-verification-errors.md"
canonical: "https://docs.adyen.com/platforms/test-verification-errors"
last_modified: "2026-05-24T12:54:31+02:00"
language: "en"
---

# Test verification/KYC scenarios

Learn how you can test your error handling flows.

[View source](/platforms/test-verification-errors.md)

When [verifying users](/platforms/verification-overview), the verification checks performed by Adyen can return a range of [error messages](/platforms/kyc-verification-codes).

In your test environment, all verification checks are passed by default when the required fields and documents are provided. To test your error handling flow, you can force a scenario where one or more verification checks fail.

This allows you to reproduce an unsuccessful verification flow, including the result and corresponding [verification codes](/platforms/kyc-verification-codes). You can then also test the remediating flow to resolve the verification errors.

## Requirements

Before you begin, take into account the following requirements, limitations, and preparations.

| Requirement                                                    | Description                                                                                                                                                                                                                                                                                                                                                                         |
| -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Integration type**                                           | You have an [Adyen for Platforms](/adyen-for-platforms-model/) or [Adyen Issuing](/issuing) integration.                                                                                                                                                                                                                                                                            |
| **[API credentials](/development-resources/api-credentials/)** | You must have a API credential for [legal entity management](/platforms/manage-access/api-credentials-web-service). To check verification errors by making API requests, you must have a [API web service user credential](/platforms/manage-access/api-credentials-web-service) for the [Configuration API](https://docs.adyen.com/api-explorer/balanceplatform/latest/overview).. |
| **[Webhooks](/development-resources/webhooks)**                | To get updates about the failed verification, make sure you are subscribed to the [balancePlatform.accountHolder.updated](https://docs.adyen.com/api-explorer/#/balanceplatform-webhooks/latest/post/balancePlatform.accountHolder.updated)                                                                                                                                         |

## Step 1: Make an API request

Using the [Legal Entity Management API](https://docs.adyen.com/api-explorer/legalentity/latest/overview), you can include a [x-requested-verification-code](https://docs.adyen.com/api-explorer/legalentity/latest/post/legalEntities#header-x_requested_verification_code) in the header of your API request.

Note that requested verification codes cannot be used with hosted onboarding.

You can use requested verification codes for the following endpoints:

* [POST /legalEntities](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/legalEntities)
* [POST /documents](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/documents)
* [POST /transferInstruments](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/transferInstruments)

Use a [suberror code](/platforms/kyc-verification-codes/sub-errors) as your requested verification code. You can include one code at a time in your request header. Requested verification codes can only be used in your test environment.

### Tab: Legal entities

In this example, you want to test the `1_3004` suberror code `The name and residence country couldn't be verified` for an individual legal entity. This triggers the following verification checks:

* Name and date of birth check
* Residency country check

In the header of your POST [/legalEntities](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/legalEntities) request, include `x-requested-verification-code: 1_3004`.

**Force legal entity verification**

#### curl

```bash
curl https://kyc-test.adyen.com/lem/v3/legalEntities \
-H 'x-api-key: ADYEN_LEGAL_ENTITY_MANAGEMENT_API_KEY' \
-H 'content-type: application/json' \
-H 'x-requested-verification-code: 1_3004' \
-X POST \
-d '{
    "type": "individual",
    "individual": {
        "phone": {
            "number": "+31612345678",
            "type": "mobile"
        },
        "birthData": {
            "dateOfBirth": "1977-01-01"
        },
        "name": {
            "firstName": "KYC",
            "lastName": "My Test scenario"
        },
        "nationality": "NL",
        "residentialAddress": {
            "city": "Amsterdam",
            "country": "NL",
            "postalCode": "1111AB",
            "street": "Main street"
        },
        "identificationData": {
            "type": "nationalIdNumber",
            "number": "12345678",
            "issuerState": "NL"
        }
    }
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.legalEntityManagement.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.legalEntityManagement.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
IdentificationData identificationData = new IdentificationData()
  .issuerState("NL")
  .number("12345678")
  .type(IdentificationData.TypeEnum.NATIONALIDNUMBER);

PhoneNumber phoneNumber = new PhoneNumber()
  .number("+31612345678")
  .type("mobile");

Address address = new Address()
  .country("NL")
  .city("Amsterdam")
  .street("Main street")
  .postalCode("1111AB");

Name name = new Name()
  .firstName("KYC")
  .lastName("My Test scenario");

BirthData birthData = new BirthData()
  .dateOfBirth("1977-01-01");

Individual individual = new Individual()
  .identificationData(identificationData)
  .nationality("NL")
  .phone(phoneNumber)
  .residentialAddress(address)
  .name(name)
  .birthData(birthData);

LegalEntityInfoRequiredType legalEntityInfoRequiredType = new LegalEntityInfoRequiredType()
  .individual(individual)
  .type(LegalEntityInfoRequiredType.TypeEnum.INDIVIDUAL);

// Make the API call
LegalEntitiesApi service = new LegalEntitiesApi(client);
LegalEntity response = service.createLegalEntity(legalEntityInfoRequiredType, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\LegalEntityManagement\IdentificationData;
use Adyen\Model\LegalEntityManagement\PhoneNumber;
use Adyen\Model\LegalEntityManagement\Address;
use Adyen\Model\LegalEntityManagement\Name;
use Adyen\Model\LegalEntityManagement\BirthData;
use Adyen\Model\LegalEntityManagement\Individual;
use Adyen\Model\LegalEntityManagement\LegalEntityInfoRequiredType;
use Adyen\Service\LegalEntityManagement\LegalEntitiesApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$identificationData = new IdentificationData();
$identificationData
  ->setIssuerState("NL")
  ->setNumber("12345678")
  ->setType("nationalIdNumber");

$phoneNumber = new PhoneNumber();
$phoneNumber
  ->setNumber("+31612345678")
  ->setType("mobile");

$address = new Address();
$address
  ->setCountry("NL")
  ->setCity("Amsterdam")
  ->setStreet("Main street")
  ->setPostalCode("1111AB");

$name = new Name();
$name
  ->setFirstName("KYC")
  ->setLastName("My Test scenario");

$birthData = new BirthData();
$birthData
  ->setDateOfBirth("1977-01-01");

$individual = new Individual();
$individual
  ->setIdentificationData($identificationData)
  ->setNationality("NL")
  ->setPhone($phoneNumber)
  ->setResidentialAddress($address)
  ->setName($name)
  ->setBirthData($birthData);

$legalEntityInfoRequiredType = new LegalEntityInfoRequiredType();
$legalEntityInfoRequiredType
  ->setIndividual($individual)
  ->setType("individual");

// Make the API call
$service = new LegalEntitiesApi($client);
$response = $service->createLegalEntity($legalEntityInfoRequiredType);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.LegalEntityManagement;
using Adyen.Service.LegalEntityManagement;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
IdentificationData identificationData = new IdentificationData
{
  IssuerState = "NL",
  Number = "12345678",
  Type = IdentificationData.TypeEnum.NationalIdNumber
};

PhoneNumber phoneNumber = new PhoneNumber
{
  Number = "+31612345678",
  Type = "mobile"
};

Address address = new Address
{
  Country = "NL",
  City = "Amsterdam",
  Street = "Main street",
  PostalCode = "1111AB"
};

Name name = new Name
{
  FirstName = "KYC",
  LastName = "My Test scenario"
};

BirthData birthData = new BirthData
{
  DateOfBirth = "1977-01-01"
};

Individual individual = new Individual
{
  IdentificationData = identificationData,
  Nationality = "NL",
  Phone = phoneNumber,
  ResidentialAddress = address,
  Name = name,
  BirthData = birthData
};

LegalEntityInfoRequiredType legalEntityInfoRequiredType = new LegalEntityInfoRequiredType
{
  Individual = individual,
  Type = LegalEntityInfoRequiredType.TypeEnum.Individual
};

// Make the API call
var service = new LegalEntitiesService(client);
var response = service.CreateLegalEntity(legalEntityInfoRequiredType);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
const { Client, LegalEntityManagementAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const legalEntityInfoRequiredType = {
  type: "individual",
  individual: {
    phone: {
      number: "+31612345678",
      type: "mobile"
    },
    birthData: {
      dateOfBirth: new Date("1977-01-01")
    },
    name: {
      firstName: "KYC",
      lastName: "My Test scenario"
    },
    nationality: "NL",
    residentialAddress: {
      city: "Amsterdam",
      country: "NL",
      postalCode: "1111AB",
      street: "Main street"
    },
    identificationData: {
      type: "nationalIdNumber",
      number: "12345678",
      issuerState: "NL"
    }
  }
}

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.LegalEntitiesApi.createLegalEntity(legalEntityInfoRequiredType);
```

#### Go

```go
// Adyen Go API Library v9.3.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/legalEntityManagement"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
identificationData := legalEntityManagement.IdentificationData{
  IssuerState: common.PtrString("NL"),
  Number: common.PtrString("12345678"),
  Type: "nationalIdNumber",
}

phoneNumber := legalEntityManagement.PhoneNumber{
  Number: "+31612345678",
  Type: common.PtrString("mobile"),
}

address := legalEntityManagement.Address{
  Country: "NL",
  City: common.PtrString("Amsterdam"),
  Street: common.PtrString("Main street"),
  PostalCode: common.PtrString("1111AB"),
}

name := legalEntityManagement.Name{
  FirstName: "KYC",
  LastName: "My Test scenario",
}

birthData := legalEntityManagement.BirthData{
  DateOfBirth: common.PtrString("1977-01-01"),
}

individual := legalEntityManagement.Individual{
  IdentificationData: &identificationData,
  Nationality: common.PtrString("NL"),
  Phone: &phoneNumber,
  ResidentialAddress: address,
  Name: name,
  BirthData: &birthData,
}

legalEntityInfoRequiredType := legalEntityManagement.LegalEntityInfoRequiredType{
  Individual: &individual,
  Type: "individual",
}

// Make the API call
service := client.LegalEntityManagement()
req := service.LegalEntitiesApi.CreateLegalEntityInput().LegalEntityInfoRequiredType(legalEntityInfoRequiredType)
res, httpRes, err := service.LegalEntitiesApi.CreateLegalEntity(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "type": "individual",
  "individual": {
    "phone": {
      "number": "+31612345678",
      "type": "mobile"
    },
    "birthData": {
      "dateOfBirth": "1977-01-01"
    },
    "name": {
      "firstName": "KYC",
      "lastName": "My Test scenario"
    },
    "nationality": "NL",
    "residentialAddress": {
      "city": "Amsterdam",
      "country": "NL",
      "postalCode": "1111AB",
      "street": "Main street"
    },
    "identificationData": {
      "type": "nationalIdNumber",
      "number": "12345678",
      "issuerState": "NL"
    }
  }
}

# Make the API call
result = adyen.legalEntityManagement.legal_entities_api.create_legal_entity(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :type => 'individual',
  :individual => {
    :phone => {
      :number => '+31612345678',
      :type => 'mobile'
    },
    :birthData => {
      :dateOfBirth => '1977-01-01'
    },
    :name => {
      :firstName => 'KYC',
      :lastName => 'My Test scenario'
    },
    :nationality => 'NL',
    :residentialAddress => {
      :city => 'Amsterdam',
      :country => 'NL',
      :postalCode => '1111AB',
      :street => 'Main street'
    },
    :identificationData => {
      :type => 'nationalIdNumber',
      :number => '12345678',
      :issuerState => 'NL'
    }
  }
}

# Make the API call
result = adyen.legalEntityManagement.legal_entities_api.create_legal_entity(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, LegalEntityManagementAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const identificationData: Types.legalEntityManagement.IdentificationData = {
  issuerState: "NL",
  number: "12345678",
  type: Types.legalEntityManagement.IdentificationData.TypeEnum.NationalIdNumber
};

const phoneNumber: Types.legalEntityManagement.PhoneNumber = {
  number: "+31612345678",
  type: "mobile"
};

const address: Types.legalEntityManagement.Address = {
  country: "NL",
  city: "Amsterdam",
  street: "Main street",
  postalCode: "1111AB"
};

const name: Types.legalEntityManagement.Name = {
  firstName: "KYC",
  lastName: "My Test scenario"
};

const birthData: Types.legalEntityManagement.BirthData = {
  dateOfBirth: "1977-01-01"
};

const individual: Types.legalEntityManagement.Individual = {
  identificationData: identificationData,
  nationality: "NL",
  phone: phoneNumber,
  residentialAddress: address,
  name: name,
  birthData: birthData
};

const legalEntityInfoRequiredType: Types.legalEntityManagement.LegalEntityInfoRequiredType = {
  individual: individual,
  type: Types.legalEntityManagement.LegalEntityInfoRequiredType.TypeEnum.Individual
};

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.LegalEntitiesApi.createLegalEntity(legalEntityInfoRequiredType);
```

### Tab: Documents

In this example, you want to test the `1_3008` suberror code `The ID document image was incomplete` for a document.

In the header of your POST [/documents](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/documents) request, include `x-requested-verification-code: 1_3008`.

**Force document verification**

#### curl

```bash
curl https://kyc-test.adyen.com/lem/v3/documents \
-H 'x-api-key: ADYEN_LEGAL_ENTITY_MANAGEMENT_API_KEY' \
-H 'content-type: application/json' \
-H 'x-requested-verification-code: 1_3008' \
-X POST \
-d '{
    "owner": {
      "id": "LE00000000000000000000001",
      "type": "legalEntity"
    },
    "description": "YOUR_DESCRIPTION",
    "type": "identityCard",
    "issuerCountry" : "NL",
    "attachments": [
      {
        "content": "R0lGODlhhAMKAeZOADs..",
        "pageType": "front"
      },
      {
        "content": "P3lhKWTpN0LXaPTI0Gs..",
        "pageType": "back"
      }
    ]
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.legalEntityManagement.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.legalEntityManagement.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
OwnerEntity ownerEntity = new OwnerEntity()
  .id("LE00000000000000000000001")
  .type("legalEntity");

Attachment attachment1 = new Attachment()
  .pageType("front");

Attachment attachment2 = new Attachment()
  .pageType("back");

Document document = new Document()
  .owner(ownerEntity)
  .issuerCountry("NL")
  .attachments(Arrays.asList(attachment1, attachment2))
  .description("YOUR_DESCRIPTION")
  .type(Document.TypeEnum.IDENTITYCARD);

// Make the API call
DocumentsApi service = new DocumentsApi(client);
Document response = service.uploadDocumentForVerificationChecks(document, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\LegalEntityManagement\OwnerEntity;
use Adyen\Model\LegalEntityManagement\Attachment;
use Adyen\Model\LegalEntityManagement\Document;
use Adyen\Service\LegalEntityManagement\DocumentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$ownerEntity = new OwnerEntity();
$ownerEntity
  ->setId("LE00000000000000000000001")
  ->setType("legalEntity");

$attachment1 = new Attachment();
$attachment1
  ->setPageType("front");

$attachment2 = new Attachment();
$attachment2
  ->setPageType("back");

$document = new Document();
$document
  ->setOwner($ownerEntity)
  ->setIssuerCountry("NL")
  ->setAttachments(array($attachment1, $attachment2))
  ->setDescription("YOUR_DESCRIPTION")
  ->setType("identityCard");

// Make the API call
$service = new DocumentsApi($client);
$response = $service->uploadDocumentForVerificationChecks($document);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.LegalEntityManagement;
using Adyen.Service.LegalEntityManagement;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
OwnerEntity ownerEntity = new OwnerEntity
{
  Id = "LE00000000000000000000001",
  Type = "legalEntity"
};

Attachment attachment1 = new Attachment
{
  PageType = "front"
};

Attachment attachment2 = new Attachment
{
  PageType = "back"
};

Document document = new Document
{
  Owner = ownerEntity,
  IssuerCountry = "NL",
  Attachments = new List<Attachment>{ attachment1, attachment2 },
  Description = "YOUR_DESCRIPTION",
  Type = Document.TypeEnum.IdentityCard
};

// Make the API call
var service = new DocumentsService(client);
var response = service.UploadDocumentForVerificationChecks(document);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
const { Client, LegalEntityManagementAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const document = {
  owner: {
    id: "LE00000000000000000000001",
    type: "legalEntity"
  },
  description: "YOUR_DESCRIPTION",
  type: "identityCard",
  issuerCountry: "NL",
  attachments: [ {
    content: "R0lGODlhhAMKAeZOADs..",
    pageType: "front"
  }, {
    content: "P3lhKWTpN0LXaPTI0Gs..",
    pageType: "back"
  } ]
}

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.DocumentsApi.uploadDocumentForVerificationChecks(document);
```

#### Go

```go
// Adyen Go API Library v9.3.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/legalEntityManagement"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
ownerEntity := legalEntityManagement.OwnerEntity{
  Id: "LE00000000000000000000001",
  Type: "legalEntity",
}

attachment1 := legalEntityManagement.Attachment{
  PageType: common.PtrString("front"),
}

attachment2 := legalEntityManagement.Attachment{
  PageType: common.PtrString("back"),
}

document := legalEntityManagement.Document{
  Owner: &ownerEntity,
  IssuerCountry: common.PtrString("NL"),
  Attachments: []legalEntityManagement.Attachment{
      attachment1, attachment2,
  },
  Description: "YOUR_DESCRIPTION",
  Type: "identityCard",
}

// Make the API call
service := client.LegalEntityManagement()
req := service.DocumentsApi.UploadDocumentForVerificationChecksInput().Document(document)
res, httpRes, err := service.DocumentsApi.UploadDocumentForVerificationChecks(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "owner": {
    "id": "LE00000000000000000000001",
    "type": "legalEntity"
  },
  "description": "YOUR_DESCRIPTION",
  "type": "identityCard",
  "issuerCountry": "NL",
  "attachments": [ {
    "content": "R0lGODlhhAMKAeZOADs..",
    "pageType": "front"
  }, {
    "content": "P3lhKWTpN0LXaPTI0Gs..",
    "pageType": "back"
  } ]
}

# Make the API call
result = adyen.legalEntityManagement.documents_api.upload_document_for_verification_checks(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :owner => {
    :id => 'LE00000000000000000000001',
    :type => 'legalEntity'
  },
  :description => 'YOUR_DESCRIPTION',
  :type => 'identityCard',
  :issuerCountry => 'NL',
  :attachments => [ {
    :content => 'R0lGODlhhAMKAeZOADs..',
    :pageType => 'front'
  }, {
    :content => 'P3lhKWTpN0LXaPTI0Gs..',
    :pageType => 'back'
  } ]
}

# Make the API call
result = adyen.legalEntityManagement.documents_api.upload_document_for_verification_checks(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, LegalEntityManagementAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const ownerEntity: Types.legalEntityManagement.OwnerEntity = {
  id: "LE00000000000000000000001",
  type: "legalEntity"
};

const attachment1: Types.legalEntityManagement.Attachment = {
  pageType: "front"
};

const attachment2: Types.legalEntityManagement.Attachment = {
  pageType: "back"
};

const document: Types.legalEntityManagement.Document = {
  owner: ownerEntity,
  issuerCountry: "NL",
  attachments: [attachment1, attachment2],
  description: "YOUR_DESCRIPTION",
  type: Types.legalEntityManagement.Document.TypeEnum.IdentityCard
};

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.DocumentsApi.uploadDocumentForVerificationChecks(document);
```

### Tab: Transfer instruments

In this example, you want to test the `1_7002` suberror code `The bank account number wasn't valid` for a transfer instrument.

In the header of your POST [/transferInstruments](https://docs.adyen.com/api-explorer/#/legalentity/latest/post/transferInstruments) request, include `x-requested-verification-code: 1_7002`.

**Force transfer instrument verification**

#### curl

```bash
curl https://kyc-test.adyen.com/lem/v3/transferInstruments \
-H 'x-api-key: ADYEN_LEGAL_ENTITY_MANAGEMENT_API_KEY' \
-H 'content-type: application/json' \
-H 'x-requested-verification-code: 1_7002' \
-X POST \
-d '{
    "legalEntityId": "LE00000000000000000000001",
    "type": "bankAccount",
    "bankAccount": {
      "accountIdentification": {
        "type": "iban",
        "iban": "NL02XXXX0123456789"
      }
    }
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.legalEntityManagement.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.legalEntityManagement.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
IbanAccountIdentification ibanAccountIdentification = new IbanAccountIdentification()
  .iban("NL02XXXX0123456789")
  .type(IbanAccountIdentification.TypeEnum.IBAN);

BankAccountInfo bankAccountInfo = new BankAccountInfo()
  .accountIdentification(new TransferInstrumentInfoAccountIdentification(ibanAccountIdentification));

TransferInstrumentInfo transferInstrumentInfo = new TransferInstrumentInfo()
  .bankAccount(bankAccountInfo)
  .legalEntityId("LE00000000000000000000001")
  .type(TransferInstrumentInfo.TypeEnum.BANKACCOUNT);

// Make the API call
TransferInstrumentsApi service = new TransferInstrumentsApi(client);
TransferInstrument response = service.createTransferInstrument(transferInstrumentInfo, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\LegalEntityManagement\TransferInstrumentInfoAccountIdentification;
use Adyen\Model\LegalEntityManagement\BankAccountInfo;
use Adyen\Service\LegalEntityManagement\TransferInstrumentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$transferInstrumentInfoAccountIdentification = new TransferInstrumentInfoAccountIdentification();
$transferInstrumentInfoAccountIdentification
  ->setIban("NL02XXXX0123456789")
  ->setType("iban");

$bankAccountInfo = new BankAccountInfo();
$bankAccountInfo
  ->setAccountIdentification($transferInstrumentInfoAccountIdentification);

$transferInstrumentInfo = new TransferInstrumentInfo();
$transferInstrumentInfo
  ->setBankAccount($bankAccountInfo)
  ->setLegalEntityId("LE00000000000000000000001")
  ->setType("bankAccount");

// Make the API call
$service = new TransferInstrumentsApi($client);
$response = $service->createTransferInstrument($transferInstrumentInfo);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.LegalEntityManagement;
using Adyen.Service.LegalEntityManagement;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
IbanAccountIdentification ibanAccountIdentification = new IbanAccountIdentification
{
  Iban = "NL02XXXX0123456789",
  Type = IbanAccountIdentification.TypeEnum.Iban
};

BankAccountInfo bankAccountInfo = new BankAccountInfo
{
  AccountIdentification = new TransferInstrumentInfoAccountIdentification(ibanAccountIdentification)
};

TransferInstrumentInfo transferInstrumentInfo = new TransferInstrumentInfo
{
  BankAccount = bankAccountInfo,
  LegalEntityId = "LE00000000000000000000001",
  Type = TransferInstrumentInfo.TypeEnum.BankAccount
};

// Make the API call
var service = new TransferInstrumentsService(client);
var response = service.CreateTransferInstrument(transferInstrumentInfo);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
const { Client, LegalEntityManagementAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const transferInstrumentInfo = {
  legalEntityId: "LE00000000000000000000001",
  type: "bankAccount",
  bankAccount: {
    accountIdentification: {
      type: "iban",
      iban: "NL02XXXX0123456789"
    }
  }
}

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.TransferInstrumentsApi.createTransferInstrument(transferInstrumentInfo);
```

#### Go

```go
// Adyen Go API Library v9.3.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/legalEntityManagement"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
ibanAccountIdentification := legalEntityManagement.IbanAccountIdentification{
  Iban: "NL02XXXX0123456789",
  Type: "iban",
}

bankAccountInfo := legalEntityManagement.BankAccountInfo{
  AccountIdentification: legalEntityManagement.IbanAccountIdentificationAsTransferInstrumentInfoAccountIdentification(&ibanAccountIdentification),
}

transferInstrumentInfo := legalEntityManagement.TransferInstrumentInfo{
  BankAccount: bankAccountInfo,
  LegalEntityId: "LE00000000000000000000001",
  Type: "bankAccount",
}

// Make the API call
service := client.LegalEntityManagement()
req := service.TransferInstrumentsApi.CreateTransferInstrumentInput().TransferInstrumentInfo(transferInstrumentInfo)
res, httpRes, err := service.TransferInstrumentsApi.CreateTransferInstrument(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "legalEntityId": "LE00000000000000000000001",
  "type": "bankAccount",
  "bankAccount": {
    "accountIdentification": {
      "type": "iban",
      "iban": "NL02XXXX0123456789"
    }
  }
}

# Make the API call
result = adyen.legalEntityManagement.transfer_instruments_api.create_transfer_instrument(request=json_request)
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :legalEntityId => 'LE00000000000000000000001',
  :type => 'bankAccount',
  :bankAccount => {
    :accountIdentification => {
      :type => 'iban',
      :iban => 'NL02XXXX0123456789'
    }
  }
}

# Make the API call
result = adyen.legalEntityManagement.transfer_instruments_api.create_transfer_instrument(request_body)
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, LegalEntityManagementAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const ibanAccountIdentification: Types.legalEntityManagement.IbanAccountIdentification = {
  iban: "NL02XXXX0123456789",
  type: Types.legalEntityManagement.IbanAccountIdentification.TypeEnum.Iban
};

const bankAccountInfo: Types.legalEntityManagement.BankAccountInfo = {
  accountIdentification: ibanAccountIdentification
};

const transferInstrumentInfo: Types.legalEntityManagement.TransferInstrumentInfo = {
  bankAccount: bankAccountInfo,
  legalEntityId: "LE00000000000000000000001",
  type: Types.legalEntityManagement.TransferInstrumentInfo.TypeEnum.BankAccount
};

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.TransferInstrumentsApi.createTransferInstrument(transferInstrumentInfo);
```

## Step 2: Create account holder

For error tests for legal entities, you need to [create an account holder](/platforms/onboard-users) for the legal entity of the organization, individual, or sole proprietorship.

For error tests for documents or transfer instruments, you need to [create an account holder](/platforms/onboard-users) for the legal entity who owns the resource.

## Step 3: Check verification errors

To get updates about the failed verification and the corresponding error codes, you can:

* Listen to the [balancePlatform.accountHolder.updated](https://docs.adyen.com/api-explorer/#/balanceplatform-webhooks/latest/post/balancePlatform.accountHolder.updated) or
* Make a GET API request for the particular legal entity, document, or transfer instrument.

### Tab: Legal entities

Make a GET [/legalEntities/{id}](https://docs.adyen.com/api-explorer/legalentity/latest/get/legalEntities/\(id\)) request, specifying the [id](https://docs.adyen.com/api-explorer/#/legalentity/latest/get/legalEntities/{id}) in the path.

**Verification result-API response**

```json
{
   "verificationErrors": [
      {
         "code": "1_30",
         "message": "Individual details couldn't be verified",
         "remediatingActions": [
            {
               "code": "1_300",
               "message": "Update individual details"
            }
         ],
         "subErrors": [
            {
               "code": "1_3004",
               "message": "The name and residence country couldn't be verified",
               "remediatingActions": [
                  {
                     "code": "1_305",
                     "message": "Upload a different proof of residency"
                  },
                  {
                     "code": "1_300",
                     "message": "Update individual details"
                  }
               ],
               "type": "invalidInput"
            }
         ],
         "type": "invalidInput"
      }
   ]
}
```

**Verification result-webhook**

```json
{
   "data":{
      "balancePlatform": "YOUR_BALANCE_PLATFORM",
      "accountHolder": {
         "description": "YOUR_DESCRIPTION",
         "reference": "YOUR_REFERENCE",
         "legalEntityId": "LE00000000000000000000001",
         "capabilities": {
            "sendToTransferInstrument": {
               "allowed": false,
               "requested": true,
               "enabled": true,
               "problems": [
                  {
                     "entity": {
                        "id": "LE00000000000000000000001",
                        "type": "LegalEntity"
                     },
                     "verificationErrors": [
                        {
                           "code": "1_30",
                           "message": "Individual details couldn't be verified.",
                           "remediatingActions": [
                              {
                                 "code": "1_300",
                                 "message": "Update individual details"
                              }
                           ],
                           "subErrors": [
                              {
                                 "code": "1_3004",
                                 "message": "The name and residence country couldn't be verified",
                                 "remediatingActions": [
                                    {
                                       "code": "1_305",
                                       "message": "Upload a different proof of residency"
                                    },
                                    {
                                       "code": "1_300",
                                       "message": "Update individual details"
                                    }
                                 ],
                                 "type": "invalidInput"
                              }
                           ]
                        }
                     ]
                  }
               ],
               "transferInstruments": [
                  {
                     "enabled": true,
                     "requested": true,
                     "allowed": false,
                     "id": "SE00000000000000000000001",
                     "verificationStatus": "invalid"
                  }
               ],
               "verificationStatus": "invalid"
            }
         },
         "id": "AH00000000000000000000001",
         "status": "Active"
      }
   },
   "environment": "test",
   "type": "balancePlatform.accountHolder.updated"
}
```

The response returns the specified requested verification code and associated error codes.

### Tab: Documents

Make a GET [/documents/{id}](https://docs.adyen.com/api-explorer/legalentity/latest/get/documents/\(id\)) request, specifying the id in the path.

**Verification result-API Response**

```json
{
   "verificationErrors": [
      {
         "code": "1_34",
         "message": "Image of the ID document didn't meet requirements",
         "remediatingActions": [
            {
               "code": "1_303",
               "message": "Upload a different image of the ID document"
            }
         ],
         "subErrors": [
            {
               "code": "1_3008",
               "message": "The ID document image was incomplete",
               "remediatingActions": [
                  {
                     "code": "1_303",
                     "message": "Upload a different image of the ID document"
                  }
               ],
               "type": "invalidInput"
            }
         ],
         "type": "invalidInput"
      }
   ]
}
```

**Verification result-webhook**

```json
{
   "data":{
      "balancePlatform": "YOUR_BALANCE_PLATFORM",
      "accountHolder": {
         "description": "YOUR_DESCRIPTION",
         "legalEntityId": "LE00000000000000000000001",
         "reference": "YOUR_REFERENCE",
         "capabilities": {
            "sendToTransferInstrument": {
               "allowed": false,
               "enabled": true,
               "requested": true,
               "problems": [
                  {
                     "entity": {
                        "id": "LE00000000000000000000001",
                        "type": "LegalEntity"
                     },
                     "verificationErrors": [
                        {
                           "code": "1_34",
                           "message": "Image of the ID document didn't meet requirements",
                           "remediatingActions": [
                              {
                                 "code": "1_303",
                                 "message": "Upload a different image of the ID document"
                              }
                           ],
                           "subErrors": [
                              {
                                 "code": "1_3008",
                                 "message": "The ID document image was incomplete",
                                 "remediatingActions": [
                                    {
                                       "code": "1_303",
                                       "message": "Upload a different image of the ID document"
                                    }
                                 ],
                                 "type": "invalidInput"
                              }
                           ]
                        }
                     ]
                  }
               ],
               "transferInstruments": [
                  {
                     "enabled": true,
                     "requested": true,
                     "allowed": false,
                     "id": "SE00000000000000000000001",
                     "verificationStatus": "invalid"
                  }
               ],
               "verificationStatus": "invalid"
            }
         },
         "id": "AH00000000000000000000001",
         "status": "Active"
      }
   },
   "environment": "test",
   "type": "balancePlatform.accountHolder.updated"
}
```

The response returns the specified requested verification code and associated error codes.

### Tab: Transfer instruments

Make a GET [/transferInstruments/{id}](https://docs.adyen.com/api-explorer/legalentity/latest/get/transferInstruments/\(id\)) request, specifying the id in the path.

**Verification result-API response**

```json
{
   "verificationErrors": [
      {
         "code": "1_70",
         "message": "Bank account couldn't be verified",
         "remediatingActions": [
            {
               "code": "1_700",
               "message": "Update bank account details"
            }
         ],
         "subErrors": [
            {
               "code": "1_7002",
               "message": "The bank account number wasn't valid",
               "remediatingActions": [
                  {
                     "code": "1_700",
                     "message": "Update bank account details"
                  }
               ],
               "type": "invalidInput"
            }
         ],
         "type": "invalidInput"
      }
   ]
}
```

**Verification result-webhook**

```json
{
   "data":{
      "balancePlatform": "YOUR_BALANCE_PLATFORM"
      "accountHolder": {
         "description": "YOUR_DESCRIPTION",
         "reference": "YOUR_REFERENCE",
         "legalEntityId": "LE00000000000000000000001",
         "capabilities": {
            "sendToTransferInstrument": {
               "allowed": false,
               "enabled": true,
               "requested": true,
               "problems": [
                  {
                     "entity": {
                        "id": "LE00000000000000000000001",
                        "type": "LegalEntity"
                     },
                     "verificationErrors": [
                        {
                           "code": "1_70",
                           "message": "Bank account couldn't be verified",
                           "remediatingActions": [
                              {
                                 "code": "1_700",
                                 "message": "Update bank account details"
                              }
                           ],
                           "subErrors": [
                              {
                                 "code": "1_7002",
                                 "message": "The bank account number wasn't valid",
                                 "remediatingActions": [
                                    {
                                       "code": "1_700",
                                       "message": "Update bank account details"
                                    }
                                 ],
                                 "type": "invalidInput"
                              }
                           ]
                        }
                     ],
                     "transferInstruments": [
                        {
                            "enabled": true,
                            "requested": true,
                            "allowed": false,
                            "id": "SE322KH223222Q5J4DBMJ8MQZ",
                            "verificationStatus": "invalid"
                        }
                     ]
                     "verificationStatus": "invalid"
                  }
               ]
            }
         },
         "id": "AH00000000000000000000001",
         "status": "Active"
      },
      "environment": "test",
      "type": "balancePlatform.accountHolder.updated"
   }
}
```

The response returns the specified requested verification code and associated error codes.

## Step 4: Test the remediating flow and resolve verification errors

To simulate the resolution of the verification errors, in your test environment, include the `x-requested-verification-code: 0_0001` in the header of your API request.

Note that requested verification codes cannot be used with hosted onboarding.

The requested verification code can be used for the following endpoints in the [Legal Entity Management API](https://docs.adyen.com/api-explorer/legalentity/latest/overview):

* [PATCH /legalEntities](https://docs.adyen.com/api-explorer/legalentity/latest/patch/legalEntities/_id_).
* [PATCH /documents](https://docs.adyen.com/api-explorer/#/legalentity/latest/patch/documents/_id_)
* [PATCH /transferInstruments](https://docs.adyen.com/api-explorer/#/legalentity/latest/patch/transferInstruments/_id_)

If your error handling is successful, the requested verification code resolves any suberrors associated with the legal entity, document, or transfer instrument.

### Tab: Legal Entities

Make a PATCH [/legalEntities/{id}](https://docs.adyen.com/api-explorer/legalentity/latest/patch/legalEntities/\(id\)) request, specifying the [id](https://docs.adyen.com/api-explorer/legalentity/latest/patch/legalEntities/_id_#path-id) in the path and `x-requested-verification-code: 0_0001`in the API header.

**Force legal entity remediating action flow**

#### curl

```bash
curl https://kyc-test.adyen.com/lem/v3/legalEntities/LE00000000000000000000001 \
-H 'x-api-key: ADYEN_LEGAL_ENTITY_MANAGEMENT_API_KEY' \
-H 'content-type: application/json' \
-H "x-requested-verification-code: 0_0001" \
-X PATCH \
-d '{
    "individual": {
        "phone": {
            "number": "+31612345678",
            "type": "mobile"
        },
        "birthData": {
            "dateOfBirth": "1977-01-01"
        },
        "name": {
            "firstName": "KYC",
            "lastName": "My Test scenario"
        },
        "nationality": "NL",
        "residentialAddress": {
            "city": "Amsterdam",
            "country": "NL",
            "postalCode": "1111AB",
            "street": "Main street"
        },
        "identificationData": {
            "type": "nationalIdNumber",
            "number": "12345678",
            "issuerState": "NL"
        }
    }
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.legalEntityManagement.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.legalEntityManagement.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
IdentificationData identificationData = new IdentificationData()
  .issuerState("NL")
  .number("12345678")
  .type(IdentificationData.TypeEnum.NATIONALIDNUMBER);

PhoneNumber phoneNumber = new PhoneNumber()
  .number("+31612345678")
  .type("mobile");

Address address = new Address()
  .country("NL")
  .city("Amsterdam")
  .street("Main street")
  .postalCode("1111AB");

Name name = new Name()
  .firstName("KYC")
  .lastName("My Test scenario");

BirthData birthData = new BirthData()
  .dateOfBirth("1977-01-01");

Individual individual = new Individual()
  .identificationData(identificationData)
  .nationality("NL")
  .phone(phoneNumber)
  .residentialAddress(address)
  .name(name)
  .birthData(birthData);

LegalEntityInfo legalEntityInfo = new LegalEntityInfo()
  .individual(individual);

// Make the API call
LegalEntitiesApi service = new LegalEntitiesApi(client);
LegalEntity response = service.updateLegalEntity("id", legalEntityInfo, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\LegalEntityManagement\IdentificationData;
use Adyen\Model\LegalEntityManagement\PhoneNumber;
use Adyen\Model\LegalEntityManagement\Address;
use Adyen\Model\LegalEntityManagement\Name;
use Adyen\Model\LegalEntityManagement\BirthData;
use Adyen\Model\LegalEntityManagement\Individual;
use Adyen\Model\LegalEntityManagement\LegalEntityInfo;
use Adyen\Service\LegalEntityManagement\LegalEntitiesApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$identificationData = new IdentificationData();
$identificationData
  ->setIssuerState("NL")
  ->setNumber("12345678")
  ->setType("nationalIdNumber");

$phoneNumber = new PhoneNumber();
$phoneNumber
  ->setNumber("+31612345678")
  ->setType("mobile");

$address = new Address();
$address
  ->setCountry("NL")
  ->setCity("Amsterdam")
  ->setStreet("Main street")
  ->setPostalCode("1111AB");

$name = new Name();
$name
  ->setFirstName("KYC")
  ->setLastName("My Test scenario");

$birthData = new BirthData();
$birthData
  ->setDateOfBirth("1977-01-01");

$individual = new Individual();
$individual
  ->setIdentificationData($identificationData)
  ->setNationality("NL")
  ->setPhone($phoneNumber)
  ->setResidentialAddress($address)
  ->setName($name)
  ->setBirthData($birthData);

$legalEntityInfo = new LegalEntityInfo();
$legalEntityInfo
  ->setIndividual($individual);

// Make the API call
$service = new LegalEntitiesApi($client);
$response = $service->updateLegalEntity('id', $legalEntityInfo);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.LegalEntityManagement;
using Adyen.Service.LegalEntityManagement;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
IdentificationData identificationData = new IdentificationData
{
  IssuerState = "NL",
  Number = "12345678",
  Type = IdentificationData.TypeEnum.NationalIdNumber
};

PhoneNumber phoneNumber = new PhoneNumber
{
  Number = "+31612345678",
  Type = "mobile"
};

Address address = new Address
{
  Country = "NL",
  City = "Amsterdam",
  Street = "Main street",
  PostalCode = "1111AB"
};

Name name = new Name
{
  FirstName = "KYC",
  LastName = "My Test scenario"
};

BirthData birthData = new BirthData
{
  DateOfBirth = "1977-01-01"
};

Individual individual = new Individual
{
  IdentificationData = identificationData,
  Nationality = "NL",
  Phone = phoneNumber,
  ResidentialAddress = address,
  Name = name,
  BirthData = birthData
};

LegalEntityInfo legalEntityInfo = new LegalEntityInfo
{
  Individual = individual
};

// Make the API call
var service = new LegalEntitiesService(client);
var response = service.UpdateLegalEntity("id", legalEntityInfo);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
const { Client, LegalEntityManagementAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const legalEntityInfo = {
  individual: {
    phone: {
      number: "+31612345678",
      type: "mobile"
    },
    birthData: {
      dateOfBirth: new Date("1977-01-01")
    },
    name: {
      firstName: "KYC",
      lastName: "My Test scenario"
    },
    nationality: "NL",
    residentialAddress: {
      city: "Amsterdam",
      country: "NL",
      postalCode: "1111AB",
      street: "Main street"
    },
    identificationData: {
      type: "nationalIdNumber",
      number: "12345678",
      issuerState: "NL"
    }
  }
}

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.LegalEntitiesApi.updateLegalEntity("id", legalEntityInfo);
```

#### Go

```go
// Adyen Go API Library v9.3.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/legalEntityManagement"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
identificationData := legalEntityManagement.IdentificationData{
  IssuerState: common.PtrString("NL"),
  Number: common.PtrString("12345678"),
  Type: "nationalIdNumber",
}

phoneNumber := legalEntityManagement.PhoneNumber{
  Number: "+31612345678",
  Type: common.PtrString("mobile"),
}

address := legalEntityManagement.Address{
  Country: "NL",
  City: common.PtrString("Amsterdam"),
  Street: common.PtrString("Main street"),
  PostalCode: common.PtrString("1111AB"),
}

name := legalEntityManagement.Name{
  FirstName: "KYC",
  LastName: "My Test scenario",
}

birthData := legalEntityManagement.BirthData{
  DateOfBirth: common.PtrString("1977-01-01"),
}

individual := legalEntityManagement.Individual{
  IdentificationData: &identificationData,
  Nationality: common.PtrString("NL"),
  Phone: &phoneNumber,
  ResidentialAddress: address,
  Name: name,
  BirthData: &birthData,
}

legalEntityInfo := legalEntityManagement.LegalEntityInfo{
  Individual: &individual,
}

// Make the API call
service := client.LegalEntityManagement()
req := service.LegalEntitiesApi.UpdateLegalEntityInput("id").LegalEntityInfo(legalEntityInfo)
res, httpRes, err := service.LegalEntitiesApi.UpdateLegalEntity(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "individual": {
    "phone": {
      "number": "+31612345678",
      "type": "mobile"
    },
    "birthData": {
      "dateOfBirth": "1977-01-01"
    },
    "name": {
      "firstName": "KYC",
      "lastName": "My Test scenario"
    },
    "nationality": "NL",
    "residentialAddress": {
      "city": "Amsterdam",
      "country": "NL",
      "postalCode": "1111AB",
      "street": "Main street"
    },
    "identificationData": {
      "type": "nationalIdNumber",
      "number": "12345678",
      "issuerState": "NL"
    }
  }
}

# Make the API call
result = adyen.legalEntityManagement.legal_entities_api.update_legal_entity(request=json_request, id="id")
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :individual => {
    :phone => {
      :number => '+31612345678',
      :type => 'mobile'
    },
    :birthData => {
      :dateOfBirth => '1977-01-01'
    },
    :name => {
      :firstName => 'KYC',
      :lastName => 'My Test scenario'
    },
    :nationality => 'NL',
    :residentialAddress => {
      :city => 'Amsterdam',
      :country => 'NL',
      :postalCode => '1111AB',
      :street => 'Main street'
    },
    :identificationData => {
      :type => 'nationalIdNumber',
      :number => '12345678',
      :issuerState => 'NL'
    }
  }
}

# Make the API call
result = adyen.legalEntityManagement.legal_entities_api.update_legal_entity(request_body, 'id')
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, LegalEntityManagementAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const identificationData: Types.legalEntityManagement.IdentificationData = {
  issuerState: "NL",
  number: "12345678",
  type: Types.legalEntityManagement.IdentificationData.TypeEnum.NationalIdNumber
};

const phoneNumber: Types.legalEntityManagement.PhoneNumber = {
  number: "+31612345678",
  type: "mobile"
};

const address: Types.legalEntityManagement.Address = {
  country: "NL",
  city: "Amsterdam",
  street: "Main street",
  postalCode: "1111AB"
};

const name: Types.legalEntityManagement.Name = {
  firstName: "KYC",
  lastName: "My Test scenario"
};

const birthData: Types.legalEntityManagement.BirthData = {
  dateOfBirth: "1977-01-01"
};

const individual: Types.legalEntityManagement.Individual = {
  identificationData: identificationData,
  nationality: "NL",
  phone: phoneNumber,
  residentialAddress: address,
  name: name,
  birthData: birthData
};

const legalEntityInfo: Types.legalEntityManagement.LegalEntityInfo = {
  individual: individual
};

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.LegalEntitiesApi.updateLegalEntity("id", legalEntityInfo);
```

### Tab: Documents

Make a PATCH [/documents/{id}](https://docs.adyen.com/api-explorer/legalentity/latest/patch/documents/\(id\)) request, specifying the [id](https://docs.adyen.com/api-explorer/legalentity/latest/patch/documents/_id_#path-id) in the path and `x-requested-verification-code: 0_0001`in the API header.

**Force document remediating action flow**

#### curl

```bash
curl https://kyc-test.adyen.com/lem/v3/documents/SE00000000000000000000001 \
-H 'x-api-key: ADYEN_LEGAL_ENTITY_MANAGEMENT_API_KEY' \
-H 'content-type: application/json' \
-H "x-requested-verification-code: 0_0001" \
-X PATCH \
-d '{
    "description": "YOUR_DESCRIPTION",
    "type": "identityCard",
    "issuerCountry" : "NL",
    "attachments": [
      {
        "content": "R0lGODlhhAMKAeZOADs..",
        "pageType": "front"
      },
      {
        "content": "P3lhKWTpN0LXaPTI0Gs..",
        "pageType": "back"
      }
    ]
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.legalEntityManagement.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.legalEntityManagement.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
Attachment attachment1 = new Attachment()
  .pageType("front");

Attachment attachment2 = new Attachment()
  .pageType("back");

Document document = new Document()
  .issuerCountry("NL")
  .attachments(Arrays.asList(attachment1, attachment2))
  .description("YOUR_DESCRIPTION")
  .type(Document.TypeEnum.IDENTITYCARD);

// Make the API call
DocumentsApi service = new DocumentsApi(client);
Document response = service.updateDocument("id", document, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\LegalEntityManagement\Attachment;
use Adyen\Model\LegalEntityManagement\Document;
use Adyen\Service\LegalEntityManagement\DocumentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$attachment1 = new Attachment();
$attachment1
  ->setPageType("front");

$attachment2 = new Attachment();
$attachment2
  ->setPageType("back");

$document = new Document();
$document
  ->setIssuerCountry("NL")
  ->setAttachments(array($attachment1, $attachment2))
  ->setDescription("YOUR_DESCRIPTION")
  ->setType("identityCard");

// Make the API call
$service = new DocumentsApi($client);
$response = $service->updateDocument('id', $document);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.LegalEntityManagement;
using Adyen.Service.LegalEntityManagement;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
Attachment attachment1 = new Attachment
{
  PageType = "front"
};

Attachment attachment2 = new Attachment
{
  PageType = "back"
};

Document document = new Document
{
  IssuerCountry = "NL",
  Attachments = new List<Attachment>{ attachment1, attachment2 },
  Description = "YOUR_DESCRIPTION",
  Type = Document.TypeEnum.IdentityCard
};

// Make the API call
var service = new DocumentsService(client);
var response = service.UpdateDocument("id", document);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
const { Client, LegalEntityManagementAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const document = {
  description: "YOUR_DESCRIPTION",
  type: "identityCard",
  issuerCountry: "NL",
  attachments: [ {
    content: "R0lGODlhhAMKAeZOADs..",
    pageType: "front"
  }, {
    content: "P3lhKWTpN0LXaPTI0Gs..",
    pageType: "back"
  } ]
}

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.DocumentsApi.updateDocument("id", document);
```

#### Go

```go
// Adyen Go API Library v9.3.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/legalEntityManagement"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
attachment1 := legalEntityManagement.Attachment{
  PageType: common.PtrString("front"),
}

attachment2 := legalEntityManagement.Attachment{
  PageType: common.PtrString("back"),
}

document := legalEntityManagement.Document{
  IssuerCountry: common.PtrString("NL"),
  Attachments: []legalEntityManagement.Attachment{
      attachment1, attachment2,
  },
  Description: "YOUR_DESCRIPTION",
  Type: "identityCard",
}

// Make the API call
service := client.LegalEntityManagement()
req := service.DocumentsApi.UpdateDocumentInput("id").Document(document)
res, httpRes, err := service.DocumentsApi.UpdateDocument(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "description": "YOUR_DESCRIPTION",
  "type": "identityCard",
  "issuerCountry": "NL",
  "attachments": [ {
    "content": "R0lGODlhhAMKAeZOADs..",
    "pageType": "front"
  }, {
    "content": "P3lhKWTpN0LXaPTI0Gs..",
    "pageType": "back"
  } ]
}

# Make the API call
result = adyen.legalEntityManagement.documents_api.update_document(request=json_request, id="id")
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :description => 'YOUR_DESCRIPTION',
  :type => 'identityCard',
  :issuerCountry => 'NL',
  :attachments => [ {
    :content => 'R0lGODlhhAMKAeZOADs..',
    :pageType => 'front'
  }, {
    :content => 'P3lhKWTpN0LXaPTI0Gs..',
    :pageType => 'back'
  } ]
}

# Make the API call
result = adyen.legalEntityManagement.documents_api.update_document(request_body, 'id')
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, LegalEntityManagementAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const attachment1: Types.legalEntityManagement.Attachment = {
  pageType: "front"
};

const attachment2: Types.legalEntityManagement.Attachment = {
  pageType: "back"
};

const document: Types.legalEntityManagement.Document = {
  issuerCountry: "NL",
  attachments: [attachment1, attachment2],
  description: "YOUR_DESCRIPTION",
  type: Types.legalEntityManagement.Document.TypeEnum.IdentityCard
};

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.DocumentsApi.updateDocument("id", document);
```

### Tab: Transfer Instruments

Make a PATCH [/transferInstruments/{id}](https://docs.adyen.com/api-explorer/legalentity/latest/patch/transferInstruments/\(id\)) request, specifying the [id](https://docs.adyen.com/api-explorer/legalentity/latest/patch/transferInstruments/_id_#path-id) in the path and `x-requested-verification-code: 0_0001`in the API header.

**Force transfer instrument remediating action flow**

#### curl

```bash
curl https://kyc-test.adyen.com/lem/v3/transferInstruments/SE00000000000000000000001 \
-H 'x-api-key: ADYEN_LEGAL_ENTITY_MANAGEMENT_API_KEY' \
-H 'content-type: application/json' \
-H "x-requested-verification-code: 0_0001" \
-X PATCH \
-d '{
    "type": "bankAccount",
    "bankAccount": {
      "countryCode": "NL",
      "currencyCode": "EUR",
      "iban": "NL02XXXX0123456789"
    }
}'
```

#### Java

```java
// Adyen Java API Library v25.0.0
import com.adyen.Client;
import com.adyen.enums.Environment;
import com.adyen.model.legalEntityManagement.*;
import java.time.OffsetDateTime;
import java.util.*;
import com.adyen.service.legalEntityManagement.*;

Client client = new Client("ADYEN_API_KEY", Environment.TEST);

// Create the request object(s)
BankAccountInfo bankAccountInfo = new BankAccountInfo()
  .countryCode("NL");

TransferInstrumentInfo transferInstrumentInfo = new TransferInstrumentInfo()
  .bankAccount(bankAccountInfo)
  .type(TransferInstrumentInfo.TypeEnum.BANKACCOUNT);

// Make the API call
TransferInstrumentsApi service = new TransferInstrumentsApi(client);
TransferInstrument response = service.updateTransferInstrument("id", transferInstrumentInfo, null);
```

#### PHP

```php
// Adyen PHP API Library v17.4.0
use Adyen\Client;
use Adyen\Environment;
use Adyen\Model\LegalEntityManagement\BankAccountInfo;
use Adyen\Model\LegalEntityManagement\TransferInstrumentInfo;
use Adyen\Service\LegalEntityManagement\TransferInstrumentsApi;

$client = new Client();
$client->setXApiKey("ADYEN_API_KEY");
$client->setEnvironment(Environment::TEST);


// Create the request object(s)
$bankAccountInfo = new BankAccountInfo();
$bankAccountInfo
  ->setCountryCode("NL");

$transferInstrumentInfo = new TransferInstrumentInfo();
$transferInstrumentInfo
  ->setBankAccount($bankAccountInfo)
  ->setType("bankAccount");

// Make the API call
$service = new TransferInstrumentsApi($client);
$response = $service->updateTransferInstrument('id', $transferInstrumentInfo);
```

#### C\#

```cs
// Adyen .net API Library v14.4.0
using Adyen;
using Environment = Adyen.Model.Environment;
using Adyen.Model;
using Adyen.Model.LegalEntityManagement;
using Adyen.Service.LegalEntityManagement;

var config = new Config()
{
    XApiKey = "ADYEN_API_KEY",
    Environment = Environment.Test
};
var client = new Client(config);

// Create the request object(s)
BankAccountInfo bankAccountInfo = new BankAccountInfo
{
  CountryCode = "NL"
};

TransferInstrumentInfo transferInstrumentInfo = new TransferInstrumentInfo
{
  BankAccount = bankAccountInfo,
  Type = TransferInstrumentInfo.TypeEnum.BankAccount
};

// Make the API call
var service = new TransferInstrumentsService(client);
var response = service.UpdateTransferInstrument("id", transferInstrumentInfo);
```

#### NodeJS (JavaScript)

```js
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
const { Client, LegalEntityManagementAPI } = require('@adyen/api-library');
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const transferInstrumentInfo = {
  type: "bankAccount",
  bankAccount: {
    countryCode: "NL",
    currencyCode: "EUR",
    iban: "NL02XXXX0123456789"
  }
}

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.TransferInstrumentsApi.updateTransferInstrument("id", transferInstrumentInfo);
```

#### Go

```go
// Adyen Go API Library v9.3.0
import (
  "context"
  "github.com/adyen/adyen-go-api-library/v9/src/common"
  "github.com/adyen/adyen-go-api-library/v9/src/adyen"
  "github.com/adyen/adyen-go-api-library/v9/src/legalEntityManagement"
)
client := adyen.NewClient(&common.Config{
  ApiKey:      "ADYEN_API_KEY",
  Environment: common.TestEnv,
})

// Create the request object(s)
bankAccountInfo := legalEntityManagement.BankAccountInfo{
  CountryCode: common.PtrString("NL"),
}

transferInstrumentInfo := legalEntityManagement.TransferInstrumentInfo{
  BankAccount: bankAccountInfo,
  Type: "bankAccount",
}

// Make the API call
service := client.LegalEntityManagement()
req := service.TransferInstrumentsApi.UpdateTransferInstrumentInput("id").TransferInstrumentInfo(transferInstrumentInfo)
res, httpRes, err := service.TransferInstrumentsApi.UpdateTransferInstrument(context.Background(), req)
```

#### Python

```py
# Adyen Python API Library v12.2.0
import Adyen

adyen = Adyen.Adyen()
adyen.client.xapikey = "ADYEN_API_KEY"
adyen.client.platform = "test" # The environment to use library in.

# Create the request object(s)
json_request = {
  "type": "bankAccount",
  "bankAccount": {
    "countryCode": "NL",
    "currencyCode": "EUR",
    "iban": "NL02XXXX0123456789"
  }
}

# Make the API call
result = adyen.legalEntityManagement.transfer_instruments_api.update_transfer_instrument(request=json_request, id="id")
```

#### Ruby

```rb
# Adyen Ruby API Library v9.3.0
require "adyen-ruby-api-library"

adyen = Adyen::Client.new
adyen.api_key = 'ADYEN_API_KEY'
adyen.env = :test # Set to "live" for live environment

# Create the request object(s)
request_body = {
  :type => 'bankAccount',
  :bankAccount => {
    :countryCode => 'NL',
    :currencyCode => 'EUR',
    :iban => 'NL02XXXX0123456789'
  }
}

# Make the API call
result = adyen.legalEntityManagement.transfer_instruments_api.update_transfer_instrument(request_body, 'id')
```

#### NodeJS (TypeScript)

```ts
// Adyen Node API Library v16.2.0
// Require the parts of the module you want to use
import { Client, LegalEntityManagementAPI, Types } from "@adyen/api-library";
// Initialize the client object
const client = new Client({apiKey: "ADYEN_API_KEY", environment: "TEST"});

// Create the request object(s)
const bankAccountInfo: Types.legalEntityManagement.BankAccountInfo = {
  countryCode: "NL"
};

const transferInstrumentInfo: Types.legalEntityManagement.TransferInstrumentInfo = {
  bankAccount: bankAccountInfo,
  type: Types.legalEntityManagement.TransferInstrumentInfo.TypeEnum.BankAccount
};

// Make the API call
const legalEntityManagementAPI = new LegalEntityManagementAPI(client);
const response = legalEntityManagementAPI.TransferInstrumentsApi.updateTransferInstrument("id", transferInstrumentInfo);
```