Receive-Only Entities

Receive-only entities exists solely to receive payments such as a bill payment. In this instance the receive-only entity does not need to pass KYC, as long as they are receiving payment from a fully KYC’d entity.

Receive-Only entities also cannot be end users. They do not and cannot access your platform or Sila's services like normal KYC'd end users can.

In such cases, individual or business entities can be designated "RECEIVE_ONLY" entities. Work with your account rep to enable this new receive-only KYC level for your app.

For example, businesses who have billpay as a part of their use case do not need to onboard Verizon Wireless as a business customer (or end user). Instead Verizon may provide you with an account to pay into, and then you can use Sila's receive-only entity type to set up a payment route to them so your users can pay their Verizon bill.

🚧

Receive-only Entities

Approval for use of receive-only entity types is determined on a case by case basis by Sila's compliance team. Not all requests to use the receive-only entity type can be granted.

Receive-Only entities also cannot be end users. They do not and cannot access your platform or Sila's services like normal KYC'd end users can.

Customers must remain compliant with the use of this entity such that they only receive funds from another KYC/KYB entity. The list below outlines the various capabilities and restrictions related to transactions:

You May
/transfer_sila - you may transfer sila into a receive-only entity wallet if the source of the transfer is a wallet tied to a fully KYC/KYB entity
/redeem_sila - you may redeem funds that exist in a receive-only entity wallet to their linked bank account

You May Not
/issue_sila - you may not issue sila for receive-only entities
/transfer_sila - you may not transfer sila out of a receive-only entity wallet
/transfer_sila - you may not transfer sila into a receive-only entity wallet if the source wallet of the transfer does not belong to a fully KYC/KYB entity.

Follow these steps to create a receive-only entity:

Receive-only Individuals:

  1. Create your individual entity using the /register API providing the minimum information required, detailed below.
  2. Call the /request_kyc API and specify the KYC level as “RECEIVE_ONLY”
  3. Call the /check_kyc API to confirm that the entity has been verified and is ready to transact.
  4. Call /link_account to link a bank account to this entity
  5. Entity is now ready to transact as a receive-only entity

Receive-only Businesses:

Businesses require one individual member to be linked to the business in the Administrator role:

  1. Create your individual entity using the /register API providing the minimum information required, detailed below.
  2. Create your business entity using the /register API providing the minimum information required, detailed below.
  3. Link your individual entity with the business using the /link_business_member API, and specify the Role, "administrator".
  4. Call the /request_kyc API on the business handle and specify the KYC level as “RECEIVE_ONLY."
  5. Call the /check_kyc API to confirm that the entity has been verified and ready to transact.
  6. Call /link_account to link a bank account to this entity, detailed below.
  7. Entity is now ready to transact as a receive-only entity.

/Register for receive-only entities

📘

Registering an Admin

For the purposes of registering an Admin for receive-only businesses the same individual requirements apply: first name, last name, crypto address, and email (in short).

POST /0.2/register HTTP/1.1
Host: sandbox.silamoney.com
authsignature: [GENERATED AUTHSIGNATURE HEX STRING HERE]
Content-Type: application/json

{
  "header": {
    "created": 1234567890,
    "user_handle": "user.silamoney.eth",
    "app_handle": "handle.silamoney.eth",
    "version": "0.2",
    "crypto": "ETH",
    "reference": "<your unique id>"
  },
  "message": "entity_msg",
  "contact": {
    "email": "[email protected]"
  },
  "crypto_entry": {
    "crypto_alias": "Address 1",
    "crypto_address": "0x1234567890abcdef1234567890abcdef12345678",
    "crypto_code": "ETH"
  },
  "entity": {
    "entity_name": "Example User",
    "first_name": "Example",
    "last_name": "User",
    "relationship": "user"
  }
}

***

HTTP/1.1 200 OK

{
  "success": true,
  "reference":"SOME ID",
  "message":"user.silamoney.eth was successfully registered ",
  "status":"SUCCESS"
}
POST /0.2/register HTTP/1.1
Host: sandbox.silamoney.com
authsignature: [GENERATED AUTHSIGNATURE HEX STRING HERE]
Content-Type: application/json

{
    "header": {
      "created": 1234567890,
        "app_handle": "your_app_handle.silamoney.eth",
        "user_handle": "your_business_user.silamoney.eth",
        "reference": "<your unique id>",
        "crypto": "ETH",
        "version": "0.2"
    },
    "message": "entity_msg",
    "contact": {
        "phone": "1231231234",
        "email": "[email protected]"
    },
    "entity": {
        "type": "business",
        "entity_name": "Your Business Customer, Inc.",
        "business_type": "corporation",
        "naics_code": 721
    },
    "crypto_entry": {
        "crypto_code": "ETH",
        "crypto_address": "0x67CB...E1FB"
    }
}

***
  
HTTP/1.1 200 OK

{
    "message": "your_business_user has been successfully registered!",
    "reference": "ref",
    "status": "SUCCESS"
}
// Individual user
const user = new Sila.User();
user.handle = 'user.silamoney.eth';
user.firstName = 'First';
user.lastName = 'Last';
user.country = 'US';
user.email = '[email protected]';
user.cryptoAlias = 'your_crypto_alias';
user.cryptoAddress = 'The wallet blockchain address';
user.type = 'individual';

// Business user
const user = new Sila.User();
user.handle = 'user.silamoney.eth';
user.entity_name = 'test business';
user.phone = '1234567890';
user.email = '[email protected]';
user.cryptoAlias = 'your_crypto_alias';  // Optional
user.cryptoAddress = 'The wallet blockchain address';
user.business_type = 'corporation';
user.businessTypeUuid = 'your-business-type-uuid';
user.naics_code = 721;
user.type = 'business';

const res = await Sila.register(user);

// Success Response Object
console.log(res.statusCode); // 200
console.log(res.data.success); // true
console.log(res.data.reference); // Random reference number
console.log(res.data.status); // SUCCESS
console.log(res.data.message); // User was successfully registered
# Individual User

payload = {
  "user_handle": "user.silamoney.eth",    # Required: Must not be already in use
  "first_name": "Example",                # Required
  "last_name": "User",                    # Required
  "entity_name": "Example User",          # Required
  "email": "[email protected]",              # Required:  Must be a valid email address
  "crypto_address": "0x123...890",        # Required:  Must be a valid ethereum 20 byte address starting with 0x
  "birthdate": "1990-05-19"               # Required
}

# Business user

payload = {
  "user_handle": "business_handle",
  "entity_name": "Business name",
  "phone": 1234567890,
  "email": "[email protected]",
  "crypto_address": "eth_address_3",
  "crypto_alias": "0x123...890",
  "type": "business",
  "business_type": "corporation",
  "naics_code": 721
}

# Make sure silaApp is initialized with registered app_private_key and app_handle.
User.register(silaApp, payload)

### Success Response Object
{
    status: 'SUCCESS',
    success: True,
    message: 'user.silamoney.eth has been submitted to KYC queue.',
    reference: 'd725a285-3cda-47cb-aa55-60db70460ae4',
    status_code: 200
}

### Failure Response Object
{
    status: 'FAILURE',
    message: 'error',
}
//NOTE - as of Java SDK v0.2.21, we have refactored requests to make them more flexible 
//for future modifications.  Below are examples of the new method and the original method.  
//The original method will be deprecated at some point in future SDK versions, but is 
//still valid for backwards compatibility purposes.  Please use the new method moving 
//forward as you upgrade your SDK


//The new method (use this moving forward)
// Please refer to new way of initialization for this endpoint
// Individual User
RegisterRequest request = RegisterRequest.builder()
    .address(Address.builder()
        .addressAlias("Office")
        .city("New City")
        .postalCode("97204-1234")
        .state("OR")
        .streetAddress1("123 Main Street")
        .build()
    )
    .contact(Contact.builder()
        .email("[email protected]")
        .phone("503-123-4567")
        .build()
    )
    .cryptoEntry(CryptoEntry.builder()
        .cryptoAlias("Address 1")
        .cryptoAddress("User crypto address")
        .build()
    )
    .entity(Entity.builder()
        .birthdate("1900-01-31")
        .entityName("Example User")
        .firstName("Example")
        .lastName("User")
        .build()
    )
    .identity(Identity.builder()
        .identityAlias("SSN")
        .identityValue("123452222")
        .build()
    )
    .device(Device.builder()
        .deivceFingerprint("asdfghjkl")
        .build()
    )
    .userHandle("User handle")
    .build();
    
RegisterResponse response = Register.send(request);
response.isSuccess();
response.getReference();
response.getMessage();
response.getStatus();

// Business User
BusinessType businessType; //Get business type with api.getBusinessTypes()
NaicsCategoryDescription naicsCategory; //Get naics category with api.getNaicsCategories()

RegisterRequest request = RegisterRequest.builder()
    .address(Address.builder()
        .addressAlias("Office")
        .city("New City")
        .postalCode("97204-1234")
        .state("OR")
        .streetAddress1("123 Main Street")
        .build()
    )
    .contact(Contact.builder()
        .email("[email protected]")
        .phone("503-123-4567")
        .smsOptIn(true)
        .build()
    )
    .cryptoEntry(CryptoEntry.builder()
        .cryptoAlias("Address 1")
        .cryptoAddress(DefaultConfigurations.getBusinessCryptoAddress())
        .build()
    )
    .entity(Entity.builder()
        .type("business")
        .entityName("Entity name")
        .businessType(DefaultConfigurations.getBusinessTypes().get(0).getName())
        .businessWebsite("https://www.website.com")
        .doingBusinessAs("doing business as")
        .naicsCode(DefaultConfigurations.getDefaultNaicCategoryDescription().getCode())
        .build()
    )
    .identity(Identity.builder()
        .identityAlias("EIN")
        .identityValue("123452222")
        .build()
    )
    .device(Device.builder()
        .deivceFingerprint("asdfghjkl")
        .build()
    )
    .userHandle(DefaultConfigurations.getBusinessHandle())
    .build();
RegisterResponse response = Register.send(request);
response.isSuccess();
response.getReference();
response.getMessage();
response.getStatus();


//----------------------------------------------------------------------------
//This is the original method (still valid but will soon be deprecated)


// Individual User
User user = new User(String userHandle, String firstName, String lastName, String streetAddress1, @Nullable String streetAddress2,
      String city, String state (2 characters), String postalCode (5 or 9 digit format), String phone, String email, String identityNumber (SSN format "AAA-GG-SSSS"), String cryptoAddress, Date birthdate, String country (2 characters), boolean smsOptIn, String deviceFingerprint);
ApiResponse response = api.register(user);

// Business User
BusinessType businessType; //Get business type with api.getBusinessTypes()
NaicsCategoryDescription naicsCategory; //Get naics category with api.getNaicsCategories()

BusinessUser user = new BusinessUser("userhandle", "Office", "123 Main Street",
                "street address 2", "New City", "OR", "97204-1234", "503-123-4567", "[email protected]", "123452222", "crypto address", "entity name", businessType, "https://www.website.com", "doing business as", naicsCategory, String country (2 characters), boolean smsOptIn, String deviceFingerprint);

ApiResponse response = api.registerBusiness(user);

// Success Response
System.out.println(response.getStatusCode()); // 200
System.out.println(((BaseResponse)response.getData()).getReference());// Random reference number
System.out.println(((BaseResponse)response.getData()).getStatus()); // SUCCESS
System.out.println(((BaseResponse)response.getData()).getMessage()); // user was successfully registered.
System.out.println(((BaseResponse)response.getData()).getSuccess()); // true
// Generate Wallet
//This is a helper function that allows you to generate a wallet (private key & address) that you can then use to register a new user.

// **Important!** Sila does not custody these private keys. They should *never* be sent to us or disclosed to any third party. The private key will be used to sign all requests from the associated user for authentication purposes.

$wallet = $client->generateWallet();
print $wallet->getAddress();        // e.g. 0x9ae1e2a685c5f23981757ea0cb6f5b413aa5f29f
print $wallet->getPrivateKey();     // e.g. 0xe62049e7ca71d9223c8db6751e007ce000d686b7729792160787034e1c976c12

// You can also initialize a wallet using existing values, e.g.

$privateKey = '0xe62049e7ca71d9223c8db6751e007ce000d686b7729792160787034e1c976c12';
$address = '0x9ae1e2a685c5f23981757ea0cb6f5b413aa5f29f';
$wallet = $client->generateWallet($privateKey, $address);
print $wallet->getAddress();        // e.g. 0x9ae1e2a685c5f23981757ea0cb6f5b413aa5f29f
print $wallet->getPrivateKey();     // e.g. 0xe62049e7ca71d9223c8db6751e007ce000d686b7729792160787034e1c976c12

/* Wallet has two attributes:
- `address` is the public blockchain address that will be used when you call register()
- `private_key` is the private key associated with this address. This will _only_ be used to sign requests. **Keep this safe!** */

// For individual users
use Silamoney\Client\Domain\User;

$userHandle = 'user.silamoney.eth';
$firstName = 'Sila';
$lastName = 'Money';
$email = '[email protected]';
$cryptoAddress = '0xabc123abc123abc123'; // Hex-encoded blockchain address (prefixed with "0x")


// Create user object
$user = new User($userHandle, $firstName, $lastName, $email, $cryptoAddress);

// Optional parameters can be set to null
$user = new User($userHandle, $firstName, $lastName, null, null, null, null, null, null, $email, null, $cryptoAddress, null);

// Call the api
$response = $client->register($user);

// For business users
use Silamoney\Client\Domain\BusinessUser;

// Fill your data
$businessHandle = 'business.silamoney.eth';
$name = 'Your Business Inc.';
$phone = '123-456-7890';
$email = '[email protected]';
$cryptoAddress = '0xabc123abc123abc123'; // Hex-encoded blockchain address (prefixed with "0x")
$naicsCode = 123; // The Naics code.
$businessType = 'Type'; // Required


// Create business user object
$businessUser = new BusinessUser($businessHandle, $name, $phone, $email, $cryptoAddress, $naicsCode, $businessType);

// Optional parameters can be set to null
$businessUser = new BusinessUser($businessHandle, $name, $phone, $email, null, null, null, null, null, null, $cryptoAddress, $naicsCode, $businessType, null, null, null);

// Call the api
$response = $client->registerBusiness($businessUser);


// Success 200
echo $response->getStatusCode(); // 200
echo $response->getData()->getReference(); // Random reference number
echo $response->getData()->getStatus(); // SUCCESS
echo $response->getData()->getMessage(); // User was successfully register
//NOTE - as of C# SDK v0.2.21, we have refactored requests to make them more flexible 
//for future modifications.  Below are examples of the new method and the original method.  
//The original method will be deprecated at some point in future SDK versions, but is 
//still valid for backwards compatibility purposes.  Please use the new method moving 
//forward as you upgrade your SDK

//The new method (use this moving forward)
RegisterRequest request = new RegisterRequest{
    Address = new Address{
        AddressAlias = "address alias",
        City = "city",
        PostalCode = "postal code",
        State = "state",
        StreetAddress1 = "sreet address 1",
        StreetAddress2 = "street address 2"
    },
    Contact = new Contact {
        ContactAlias = "contact alias",
        Email = "email",
        Phone = "phone",
        SmsOptIn = "sms opt in"
    },
    CryptoEntry = new CryptoEntry{
        CryptoAddress = "crypto address",
        CryptoAlias = "crypto alias"
    },
    Device = new Device {
        DeviceFingerprint = "device fingerprint"
    },
    Entity = new Entity {
        Birthdate = "1990-01-31",
        EntityName = "entity name",
        FirstName = "first name",
        LastName = "last name",
        Relationship = "relationship"
    },
    Identity = new Identity {
        IdentityAlias = "identity alias",
        IdentityValue = "identity value"
    },
    UserHandle = "user handle"
};

RegisterResponse response = Register.Send(request);

response.Success;
response.Status;
response.Message;
response.Reference;

//------------------------------------
//This is the original method (still valid but will soon be deprecated)

// Register individual user

User user = new User
{
    UserHandle = "your_user_handle",
    FirstName = "First",
    LastName = "Last",
    Birthdate = new DateTime(1900, 1, 31),
    EntityName = "First Last",
    CryptoAddress = "0x1234567890abcdef1234567890abcdef12345678",
    CryptoAlias = "Address 1",
    DeviceFingerprint = "test_instant_ach",
    Phone = "503-123-4567",
    SmsOptIn = true,
    Email = "[email protected]",
    ContactAlias = "",
    IdentityValue = "123452222",
    StreetAddress1 = "123 Main Street",
    StreetAddress2 = "",
    City = "New City",
    State = "OR",
    PostalCode = "97204-1234",
    Country = "US",
    AddressAlias = "home",
    Type = "individual"
};
ApiResponse<object> response = api.Register(user);

// Register business user

BusinessUser user = new BusinessUser
{
    UserHandle = "your_business_handle",
    EntityName = "Your Business Customer, Inc.",
    BusinessType = "corporation",
    BusinessTypeUuid = "your-business-type-uuid",
    BusinessWebsite = "https://www.yourbusinesscustomer.com",
    DoingBusinessAs = "Your Business Customer Alias Co.",
    NaicsCode = 101,
    CryptoAddress = "0x1234567890abcdef1234567890abcdef12345678",
    CryptoAlias = "Address 1",
    DeviceFingerprint = "test_instant_ach",
    Phone = "503-123-4567",
    SmsOptIn = true,
    Email = "[email protected]",
    ContactAlias = "",
    IdentityValue = "12-1234567",
    StreetAddress1 = "123 Main Street",
    StreetAddress2 = "",
    City = "New City",
    State = "OR",
    PostalCode = "97204-1234",
    Country = "US",
    AddressAlias = "home",
    Type = "business"
};
ApiResponse<object> response = api.Register(user);

// Success Response Object

Console.WriteLine(response.StatusCode); // 200
Console.WriteLine(((BaseResponse)response.Data).Reference); // Random reference number
Console.WriteLine(((BaseResponse)response.Data).Status); // SUCCESS
Console.WriteLine(((BaseResponse)response.Data).Message); // user was successfully registered.

/link_account for receive-only entities

🚧

IMPORTANT NOTICE!

Direct account linking is only available to customers who have a direct relationship with an account linking provider, or customer who have been approved for a receive-only entity use-case.

End users must never be able to enter in their account and routing numbers without verifying account ownership.

POST /0.2/link_account HTTP/1.1
Host: sandbox.silamoney.com
authsignature: [GENERATED AUTHSIGNATURE HEX STRING HERE]
usersignature: [GENERATED USERSIGNATURE HEX STRING HERE]
Content-Type: application/json

{
  "header": {
    "created": 1234567890, 
    "app_handle": "handle.silamoney.eth", 
    "user_handle":"user.silamoney.eth", 
    "version": "0.2", 
    "crypto": "ETH", 
    "reference": "ref"
  }, 
  "account_number": "123456789012",
  "routing_number": "123456789",
  "account_type": "CHECKING",
  "account_name": "Custom Account Name",
}

***

HTTP/1.1 200 OK

{
  "success": true,
  "status": "SUCCESS",
  "reference": "ref",
  "message": "Bank account successfully linked.",
  "account_name": "Custom Account Name",
  "match_score": null,
  "account_owner_name": "Sally Smith",
  "entity_name": "Sally Smith",
}
// Direct account-linking flow for receive-only entities only 
// Restricted by use-case, contact Sila for approval
const res = await Sila.linkAccountDirect(
  userHandle,
  walletPrivateKey,
  accountNumber,
  routingNumber,
  accountName,
  accountType,
); // Account Type and Account Name parameters are not required

//The only permitted account type is "CHECKING"

// Success Response Object
console.log(res.statusCode); // 200
console.log(res.data.reference); // Random reference number
console.log(res.data.status); // SUCCESS
console.log(res.data.success);
console.log(res.data.message); // Bank account successfully linked
console.log(res.data.account_name);
console.log(res.data.match_score);
console.log(res.data.account_owner_name);
console.log(res.data.entity_name);
### Direct account-linking flow for receive-only entities only 
### Restricted by use-case, contact Sila for approval
payload={
            "user_handle": "user.silamoney.eth",    # Required
            "account_number": "123456789012",       # Required
            "routing_number": "123456789",          # Required
            "account_type": "CHECKING",             # Optional (default value is CHECKING)
            "account_name": "Custom Account Name"   # Optional (default value is "default"),
        }

User.linkAccount(silaApp,payload,user_private_key)

### Success Response Object
{
    status: 'SUCCESS',
    success: True,
    message: 'Bank account successfully manually linked.',
    reference: 'f9f23fc2-26e7-4358-99c8-75cb8aec76fb',
    account_name: 'default',
    status_code: 200,
    match_score: 0.825,
    account_owner_name: 'Sally Smith',
    entity_name: 'Sally Smith'
}

### Failure Response Object
{
    status: 'FAILURE'
}
//NOTE - as of Java SDK v0.2.21, we have refactored requests to make them more flexible 
//for future modifications.  Below are examples of the new method and the original method.  
//The original method will be deprecated at some point in future SDK versions, but is 
//still valid for backwards compatibility purposes.  Please use the new method moving 
//forward as you upgrade your SDK


// Direct account-linking flow for receive-only entities only 
// Restricted by use-case, contact Sila for approval
LinkAccountRequest request = LinkAccountRequest.builder()
    .accountName("default")
    .accountNumber("123456789012")
    .routingNumber("123456789")
    .accountType("CHECKING")
    .userHandle("user handle")
    .userPrivateKey("user private key")
    .build();

LinkAccountResponse response = LinkAccount.send(request);

response.getStatus();
response.getAccountName();
response.getMessage();
response.getReference();

//--------------------------------------------

//This is the original method (still valid but will soon be deprecated)

// Direct account-linking flow for receive-only entities only 
// Restricted by use-case, contact Sila for approval
String userHandle = 'user.silamoney.eth';
String accountName = 'direct'; // Your desired account name
String accountNumber = '123456789012';
String routingNumber = '123456789';
String accountType = 'CHECKING'; // Currently the only allowed value
String userPrivateKey = 'some private key';

ApiResponse response = api.linkAccount(userHandle, userPrivateKey, accountName, accountNumber, routingNumber, accountType);

// Success Response
System.out.println(response.getStatusCode()); // 200
LinkAccountResponse parsedResponse = (LinkAccountResponse) response.getData();
System.out.println(parsedResponse.getStatus()); // SUCCESS
System.out.println(parsedResponse.isSuccess()); // true
System.out.println(parsedResponse.getReference()); // Reference number
System.out.println(parsedResponse.getMessage()); // Successfully linked
System.out.println(parsedResponse.getAccountName()); // Your desired account name
System.out.println(parsedResponse.getMatchScore()); // Match score
// Direct account-linking flow for receive-only entities only 
// Restricted by use-case, contact Sila for approval
$userHandle = 'user.silamoney.eth';
$accountName = 'Custom Account Name'; // Defaults to 'default' if not provided. (not required)
$routingNumber = '123456789'; // The routing number. 
$accountNumber = '123456789012'; // The bank account number
$userPrivateKey = 'some private key'; // The private key used to register the specified user
$accountType = 'CHECKING'; // The account type (not required). Only available value is CHECKING

// Call the api
$response = $client->linkAccountDirect($userHandle, $userPrivateKey, $accountNumber, $routingNumber, $accountName, $accountType);

// Success 200
echo $response->getStatusCode(); // 200
echo $response->getData()->getStatus(); // SUCCESS
echo $response->getData()->getReference();
echo $response->getData()->getMessage();
echo $response->getData()->getAccountName();
echo $response->getData()->getAccountOwnerName();
//NOTE - as of C# SDK v0.2.21, we have refactored requests to make them more flexible 
//for future modifications.  Below are examples of the new method and the original method.  
//The original method will be deprecated at some point in future SDK versions, but is 
//still valid for backwards compatibility purposes.  Please use the new method moving 
//forward as you upgrade your SDK


// Direct account-linking flow for receive-only entities only 
// Restricted by use-case, contact Sila for approval
LinkAccountRequest request = new LinkAccountRequest{
    UserHandle = "user handle",
    UserPrivateKey = "user private key",
    AccountName = "account name",
    AccountNumber = "account number",
    RoutingNumber = "routing number",
    AccountType = "account type"
};

LinkAccountResponse response = LinkAccount.Send(request);

response.Success;
response.Account;
response.AccountOwnerName;
response.Message;
response.Reference;
response.Status;
response.MatchScore; Account Type and Account Name parameters are not required 

//--------------------------------------
//This is the original method (still valid but will soon be deprecated)

// Direct account-linking flow for receive-only entities only 
// Restricted by use-case, contact Sila for approval
ApiResponse<object> response = api.LinkAccountDirect(userHandle, walletPrivateKey, accountNumber, routingNumber, accountType, accountName); // Account Type and Account Name parameters are not required 

// Success Response Object

Console.WriteLine(response.StatusCode); // 200
Console.WriteLine(((LinkAccountResponse)response.Data).Reference); // Random reference number
Console.WriteLine(((LinkAccountResponse)response.Data).Status); // SUCCESS
Console.WriteLine(((LinkAccountResponse)response.Data).Message); // Bank account successfully linked.
Console.WriteLine(((LinkAccountResponse)response.Data).AccountName); // Account Name.
Console.WriteLine(((LinkAccountResponse)response.Data).MatchScore);

For customers using our direct account-linking flow

The account_type is not required; if not specified, this endpoint assumes that account is a "CHECKING" account. You can also specify that this account is a "SAVINGS" account.

The account_number is required. Must be all numeric character and no longer than 17 characters.

The routing_number is required. Must be numeric and exactly 9 characters long.

  

Responses

Status Code

success Attribute

Description

200

true

Bank account successfully linked.

200

false

Bank account not successfully linked (public token may have expired; tokens expire in 30 minutes after creation).

202

false

Bank account linked, but in a frozen state. Requires manual review - email [email protected] for steps to unfreeze this bank account.

400

false

Check validation_details for more information. PRODUCT_NOT_READY indicates the account is waiting to be linked (with microdeposit verification, for instance).

401

false

authsignature or usersignature header was absent or incorrect.


Did this page help you?