# Verify bank account details

> This is Payabli documentation. For a complete page index, fetch https://docs.payabli.com/llms.txt — append .md to any page URL for lightweight markdown. For section-level indexes, query parameters, and other AI-optimized access methods, see https://docs.payabli.com/ai-agents.md

POST https://api-sandbox.payabli.com/api/Management/verifyAccountDetails/{entry}
Content-Type: application/json

Verifies a bank account and returns detailed verification results from the verification network, including bank name, account status, and response codes. Unlike a pass/fail verification, this endpoint returns granular data to support decision-making and troubleshooting.

When bank authentication is enabled for the paypoint's organization, the endpoint performs an identity verification check on the account holder. Otherwise, it performs an account existence check. When bank authentication is enabled, the `accountHolderType` and `holderName` fields are required.

Requires `inboundpayments_create` or `outboundpayments_create` permission.

Reference: https://docs.payabli.com/developers/api-reference/management/verify-account-details

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: payabliApi
  version: 1.0.0
paths:
  /Management/verifyAccountDetails/{entry}:
    post:
      operationId: verify-account-details
      summary: Verify bank account details
      description: >-
        Verifies a bank account and returns detailed verification results from
        the verification network, including bank name, account status, and
        response codes. Unlike a pass/fail verification, this endpoint returns
        granular data to support decision-making and troubleshooting.


        When bank authentication is enabled for the paypoint's organization, the
        endpoint performs an identity verification check on the account holder.
        Otherwise, it performs an account existence check. When bank
        authentication is enabled, the `accountHolderType` and `holderName`
        fields are required.


        Requires `inboundpayments_create` or `outboundpayments_create`
        permission.
      tags:
        - subpackage_management
      parameters:
        - name: entry
          in: path
          description: The paypoint's entry name identifier.
          required: true
          schema:
            type: string
        - name: requestToken
          in: header
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                $ref: >-
                  #/components/schemas/type_management:VerifyAccountDetailsResponse
        '400':
          description: Bad request/ invalid data
          content:
            application/json:
              schema:
                description: Any type
        '401':
          description: Unauthorized request.
          content:
            application/json:
              schema:
                description: Any type
        '500':
          description: Internal API Error
          content:
            application/json:
              schema:
                description: Any type
        '503':
          description: Database connection error
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/type_:PayabliApiResponse'
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                routingNumber:
                  type: string
                  description: The bank routing number to verify.
                accountNumber:
                  type: string
                  description: The bank account number to verify.
                accountType:
                  type: string
                  description: The type of bank account, such as `Checking` or `Savings`.
                country:
                  type: string
                  description: The ISO country code for the bank account, such as `US`.
                accountHolderType:
                  type: string
                  description: >-
                    The type of account holder. Accepted values are `personal`
                    or `business`. Required when bank authentication is enabled
                    for the paypoint's organization.
                holderName:
                  type: string
                  description: >-
                    The name of the bank account holder. For personal accounts,
                    provide the holder's full name (for example, `Jane Doe`);
                    the value is split on the first space into first and last
                    name. For business accounts, provide the legal business
                    name. Required when bank authentication is enabled for the
                    paypoint's organization.
              required:
                - routingNumber
                - accountNumber
servers:
  - url: https://api-sandbox.payabli.com/api
  - url: https://api.payabli.com/api
components:
  schemas:
    type_:IsSuccess:
      type: boolean
      description: >-
        Boolean indicating whether the operation was successful. A `true` value
        indicates success. A `false` value indicates failure.
      title: IsSuccess
    type_:ResponseText:
      type: string
      description: 'Response text for operation: ''Success'' or ''Declined''.'
      title: ResponseText
    type_management:BankAccountVerificationDetailsResponse:
      type: object
      properties:
        aba:
          type: string
          description: The ABA routing number that was verified.
        accountNumber:
          type: string
          description: The account number that was verified.
        isValid:
          type: boolean
          description: Whether the bank account passed verification.
        errorMessage:
          type: string
          description: Error message if the verification request failed.
        verificationResponse:
          type: string
          description: >-
            Overall verification outcome. Possible values include `Pass`,
            `Verified`, `Declined`, `NoData`, `Bypassed`, and `Error`.
        responseCode:
          type: string
          description: Response code returned by the verification network.
        responseValue:
          type: string
          description: Response value associated with the verification outcome.
        responseDescription:
          type: string
          description: Human-readable description of the verification outcome.
        bankName:
          type: string
          description: Name of the bank associated with the routing number.
        reportedAccountType:
          type: string
          description: >-
            Account type as reported by the verification network, such as
            `Checking` or `Savings`.
        accountAddedDate:
          type: string
          description: >-
            Date the account was first seen by the verification network (ISO
            8601 format).
        accountLastUpdatedDate:
          type: string
          description: >-
            Date the account record was last updated in the verification network
            (ISO 8601 format).
        accountClosedDate:
          type: string
          description: Date the account was closed, if applicable (ISO 8601 format).
      required:
        - isValid
      description: >-
        Detailed bank account verification results from the verification
        network.
      title: BankAccountVerificationDetailsResponse
    type_management:VerifyAccountDetailsResponse:
      type: object
      properties:
        isSuccess:
          $ref: '#/components/schemas/type_:IsSuccess'
        responseText:
          $ref: '#/components/schemas/type_:ResponseText'
        responseData:
          $ref: >-
            #/components/schemas/type_management:BankAccountVerificationDetailsResponse
      required:
        - responseText
      description: Response wrapper for the bank account verification details endpoint.
      title: VerifyAccountDetailsResponse
    type_:Responsedata:
      type: object
      additionalProperties:
        description: Any type
      description: The object containing the response data.
      title: Responsedata
    type_:PayabliApiResponse:
      type: object
      properties:
        isSuccess:
          $ref: '#/components/schemas/type_:IsSuccess'
        responseData:
          $ref: '#/components/schemas/type_:Responsedata'
        responseText:
          $ref: '#/components/schemas/type_:ResponseText'
      required:
        - responseText
      title: PayabliApiResponse
  securitySchemes:
    ApiKeyAuth:
      type: apiKey
      in: header
      name: requestToken

```

## SDK Code Examples

```typescript VerifyAccountDetails
import { PayabliClient } from "@payabli/sdk-node";

async function main() {
    const client = new PayabliClient({
        apiKey: "YOUR_API_KEY_HERE",
    });
    await client.management.verifyAccountDetails("entry752", {
        routingNumber: "122105278",
        accountNumber: "0000000016",
        accountType: "Checking",
        country: "US",
        accountHolderType: "personal",
        holderName: "Jane Doe",
    });
}
main();

```

```python VerifyAccountDetails
from payabli import payabli

client = payabli(
    api_key="YOUR_API_KEY_HERE",
)

client.management.verify_account_details(
    entry="entry752",
    routing_number="122105278",
    account_number="0000000016",
    account_type="Checking",
    country="US",
    account_holder_type="personal",
    holder_name="Jane Doe",
)

```

```csharp VerifyAccountDetails
using PayabliPayabliApi;
using System.Threading.Tasks;

namespace Usage;

public class Example
{
    public async Task Do() {
        var client = new PayabliPayabliApiClient(
            apiKey: "YOUR_API_KEY_HERE"
        );

        await client.Management.VerifyAccountDetailsAsync(
            "entry752",
            new VerifyAccountDetailsRequest {
                RoutingNumber = "122105278",
                AccountNumber = "0000000016",
                AccountType = "Checking",
                Country = "US",
                AccountHolderType = "personal",
                HolderName = "Jane Doe"
            }
        );
    }

}

```

```go VerifyAccountDetails
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api-sandbox.payabli.com/api/Management/verifyAccountDetails/entry752"

	payload := strings.NewReader("{\n  \"routingNumber\": \"122105278\",\n  \"accountNumber\": \"0000000016\",\n  \"accountType\": \"Checking\",\n  \"country\": \"US\",\n  \"accountHolderType\": \"personal\",\n  \"holderName\": \"Jane Doe\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("requestToken", "<apiKey>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby VerifyAccountDetails
require 'uri'
require 'net/http'

url = URI("https://api-sandbox.payabli.com/api/Management/verifyAccountDetails/entry752")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Post.new(url)
request["requestToken"] = '<apiKey>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"routingNumber\": \"122105278\",\n  \"accountNumber\": \"0000000016\",\n  \"accountType\": \"Checking\",\n  \"country\": \"US\",\n  \"accountHolderType\": \"personal\",\n  \"holderName\": \"Jane Doe\"\n}"

response = http.request(request)
puts response.read_body
```

```java VerifyAccountDetails
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.post("https://api-sandbox.payabli.com/api/Management/verifyAccountDetails/entry752")
  .header("requestToken", "<apiKey>")
  .header("Content-Type", "application/json")
  .body("{\n  \"routingNumber\": \"122105278\",\n  \"accountNumber\": \"0000000016\",\n  \"accountType\": \"Checking\",\n  \"country\": \"US\",\n  \"accountHolderType\": \"personal\",\n  \"holderName\": \"Jane Doe\"\n}")
  .asString();
```

```php VerifyAccountDetails
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://api-sandbox.payabli.com/api/Management/verifyAccountDetails/entry752', [
  'body' => '{
  "routingNumber": "122105278",
  "accountNumber": "0000000016",
  "accountType": "Checking",
  "country": "US",
  "accountHolderType": "personal",
  "holderName": "Jane Doe"
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'requestToken' => '<apiKey>',
  ],
]);

echo $response->getBody();
```

```swift VerifyAccountDetails
import Foundation

let headers = [
  "requestToken": "<apiKey>",
  "Content-Type": "application/json"
]
let parameters = [
  "routingNumber": "122105278",
  "accountNumber": "0000000016",
  "accountType": "Checking",
  "country": "US",
  "accountHolderType": "personal",
  "holderName": "Jane Doe"
] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/Management/verifyAccountDetails/entry752")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```