> 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

# Request more services with the API

> Learn how to request more Pay In or Pay Out services for a paypoint that's already boarded

> **Note**
>
> Intelligent boarding is in beta. To opt in, reach out to your Payabli contact.

A paypoint that's already boarded can request more services, such as Pay Out for a paypoint that boarded for Pay In. To request new services, create a new application for the paypoint and list the services to add in the `services` object of the request body. You don't create a new business or paypoint, and the new application goes through review. For how applications work, see [Manage applications with the API](/guides/pay-ops-developer-applications-manage).

## Considerations

* The boarding API uses OAuth2. Send a Bearer token on every request. See [OAuth2 authentication](/developers/oauth-authentication).
* You need the `businessReference` of the business that owns the paypoint.
* Request only services the paypoint doesn't already have. Payabli doesn't board a service again for a paypoint that already has it. List Pay In services under `moneyIn` and Pay Out services under `moneyOut`.

## Find the paypoint

Send a `GET` request to `/v2/paypoints` with the `businessReference` query parameter to list the business's paypoints. See the [API reference](/developers/api-reference/paypoints/list-paypoints) for this endpoint for full documentation.

### Request

GET [https://api-sandbox.payabli.com/api/v2/paypoints](https://api-sandbox.payabli.com/api/v2/paypoints)

**`ListBusinessPaypoints`**

```curl ListBusinessPaypoints
curl -G https://api-sandbox.payabli.com/api/v2/paypoints \
     -H "Authorization: Bearer <token>" \
     -d businessReference=019fed1a-3d6e-75d3-a81e-cba3874b0a55
```

**`ListBusinessPaypoints`**

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

async function main() {
    const client = new PayabliClient({
        bearerAuth: {
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET",
        },
    });
    await client.paypoints.listPaypoints({
        businessReference: "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
    });
}
main();

```

**`ListBusinessPaypoints`**

```python ListBusinessPaypoints
from payabli import payabli

client = payabli(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

client.paypoints.list_paypoints(
    business_reference="019fed1a-3d6e-75d3-a81e-cba3874b0a55",
)

```

**`ListBusinessPaypoints`**

```java ListBusinessPaypoints
package com.example.usage;

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.paypoints.requests.ListPaypointsPaypointsRequest;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient.withCredentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
            .build()
        ;

        client.paypoints().listPaypoints(
            ListPaypointsPaypointsRequest
                .builder()
                .businessReference("019fed1a-3d6e-75d3-a81e-cba3874b0a55")
                .build()
        );
    }
}
```

**`ListBusinessPaypoints`**

```csharp ListBusinessPaypoints
using PayabliApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient(
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET"
        );

        await client.Paypoints.ListPaypointsAsync(
            new ListPaypointsPaypointsRequest {
                BusinessReference = "019fed1a-3d6e-75d3-a81e-cba3874b0a55"
            }
        );
    }

}

```

**`ListBusinessPaypoints`**

```go ListBusinessPaypoints
package example

import (
    context "context"

    payabli "github.com/payabli/sdk-go"
    client "github.com/payabli/sdk-go/client"
    option "github.com/payabli/sdk-go/option"
)

func do() {
    client := client.NewClient(
        option.WithClientCredentials(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    request := &payabli.ListPaypointsPaypointsRequest{
        BusinessReference: payabli.String(
            "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
        ),
    }
    client.Paypoints.ListPaypoints(
        context.TODO(),
        request,
    )
}

```

**`ListBusinessPaypoints`**

```php ListBusinessPaypoints
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\Paypoints\Requests\ListPaypointsPaypointsRequest;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->paypoints->listPaypoints(
    new ListPaypointsPaypointsRequest([
        'businessReference' => '019fed1a-3d6e-75d3-a81e-cba3874b0a55',
    ]),
);

```

**`ListBusinessPaypoints`**

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

url = URI("https://api-sandbox.payabli.com/api/v2/paypoints?businessReference=019fed1a-3d6e-75d3-a81e-cba3874b0a55")

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

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'

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

**`ListBusinessPaypoints`**

```swift ListBusinessPaypoints
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/paypoints?businessReference=019fed1a-3d6e-75d3-a81e-cba3874b0a55")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers

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

The response lists the business's paypoints. Note the `paypointReference` of the paypoint that needs the new services:

### Response (200)

```json
{
  "success": true,
  "message": "Paypoints retrieved successfully",
  "traceId": "0HNONVR8FHLEO:0000005A",
  "data": {
    "items": [
      {
        "paypointReference": "019ff064-c690-7679-a73e-688418aadc7c",
        "parentPaypointReference": "a8806f02-23b3-4f6d-bba3-42e1b94326ea",
        "paypointStatus": "pending",
        "entryName": "8cfec329267",
        "createdAt": "2026-08-11T10:36:04.115771",
        "updatedAt": "2026-08-11T10:36:04.115788",
        "_links": {
          "self": "/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c",
          "business": "/v2/businesses/019fed1a-3d6e-75d3-a81e-cba3874b0a55"
        },
        "businessReference": "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
        "paypointType": "merchant",
        "doingBusinessAs": "Rose Gardens"
      }
    ],
    "total": 1,
    "page": 1,
    "pageSize": 25
  }
}
```

## Create an application for the paypoint

Send a `POST` request to `/v2/requests` with the `businessReference`, the `paypointReference`, and a `services` object that lists the services to add. Include `requestTemplate` with the reference of your organization's boarding template, because Payabli reviews the application with the template's underwriting settings. The paypoint must belong to the business. If it doesn't, the request fails with `404`. See the [API reference](/developers/api-reference/applications/create-an-application) for this endpoint for full documentation.

### Request

POST [https://api-sandbox.payabli.com/api/v2/requests](https://api-sandbox.payabli.com/api/v2/requests)

**`CreateApplicationForExistingPaypoint`**

```curl CreateApplicationForExistingPaypoint
curl -X POST https://api-sandbox.payabli.com/api/v2/requests \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "businessReference": "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
  "paypointReference": "019ff064-c690-7679-a73e-688418aadc7c",
  "externalId": "APP-2025-0418",
  "requestTemplate": "019ff129-d393-7761-9a31-e5afe85b4081",
  "tags": [
    "add-services"
  ],
  "services": {
    "moneyOut": [
      "Ach",
      "Check"
    ]
  }
}'
```

**`CreateApplicationForExistingPaypoint`**

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

async function main() {
    const client = new PayabliClient({
        bearerAuth: {
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET",
        },
    });
    await client.applications.createApplication({
        businessReference: "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
        paypointReference: "019ff064-c690-7679-a73e-688418aadc7c",
        externalId: "APP-2025-0418",
        requestTemplate: "019ff129-d393-7761-9a31-e5afe85b4081",
        tags: [
            "add-services",
        ],
        services: {
            moneyOut: [
                "Ach",
                "Check",
            ],
        },
    });
}
main();

```

**`CreateApplicationForExistingPaypoint`**

```python CreateApplicationForExistingPaypoint
from payabli import payabli, RequestedServices

client = payabli(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

client.applications.create_application(
    business_reference="019fed1a-3d6e-75d3-a81e-cba3874b0a55",
    paypoint_reference="019ff064-c690-7679-a73e-688418aadc7c",
    external_id="APP-2025-0418",
    request_template="019ff129-d393-7761-9a31-e5afe85b4081",
    tags=[
        "add-services"
    ],
    services=RequestedServices(
        money_out=[
            "Ach",
            "Check"
        ],
    ),
)

```

**`CreateApplicationForExistingPaypoint`**

```java CreateApplicationForExistingPaypoint
package com.example.usage;

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.applications.requests.CreateApplicationRequest;
import io.github.payabli.api.types.MoneyOutService;
import io.github.payabli.api.types.RequestedServices;
import java.util.Arrays;
import java.util.Optional;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient.withCredentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
            .build()
        ;

        client.applications().createApplication(
            CreateApplicationRequest
                .builder()
                .businessReference("019fed1a-3d6e-75d3-a81e-cba3874b0a55")
                .paypointReference("019ff064-c690-7679-a73e-688418aadc7c")
                .externalId("APP-2025-0418")
                .requestTemplate("019ff129-d393-7761-9a31-e5afe85b4081")
                .tags(
                    Optional.of(
                        Arrays.asList("add-services")
                    )
                )
                .services(
                    RequestedServices
                        .builder()
                        .moneyOut(
                            Optional.of(
                                Arrays.asList(MoneyOutService.ACH, MoneyOutService.CHECK)
                            )
                        )
                        .build()
                )
                .build()
        );
    }
}
```

**`CreateApplicationForExistingPaypoint`**

```csharp CreateApplicationForExistingPaypoint
using PayabliApi;
using System.Threading.Tasks;
using System.Collections.Generic;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient(
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET"
        );

        await client.Applications.CreateApplicationAsync(
            new CreateApplicationRequest {
                BusinessReference = "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
                PaypointReference = "019ff064-c690-7679-a73e-688418aadc7c",
                ExternalId = "APP-2025-0418",
                RequestTemplate = "019ff129-d393-7761-9a31-e5afe85b4081",
                Tags = new List<string>(){
                    "add-services",
                }
                ,
                Services = new RequestedServices {
                    MoneyOut = new List<MoneyOutService>(){
                        MoneyOutService.Ach,
                        MoneyOutService.Check,
                    }

                }
            }
        );
    }

}

```

**`CreateApplicationForExistingPaypoint`**

```go CreateApplicationForExistingPaypoint
package example

import (
    context "context"

    payabli "github.com/payabli/sdk-go"
    client "github.com/payabli/sdk-go/client"
    option "github.com/payabli/sdk-go/option"
)

func do() {
    client := client.NewClient(
        option.WithClientCredentials(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    request := &payabli.CreateApplicationRequest{
        BusinessReference: "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
        PaypointReference: payabli.String(
            "019ff064-c690-7679-a73e-688418aadc7c",
        ),
        ExternalId: payabli.String(
            "APP-2025-0418",
        ),
        RequestTemplate: payabli.String(
            "019ff129-d393-7761-9a31-e5afe85b4081",
        ),
        Tags: []string{
            "add-services",
        },
        Services: &payabli.RequestedServices{
            MoneyOut: []payabli.MoneyOutService{
                payabli.MoneyOutServiceAch,
                payabli.MoneyOutServiceCheck,
            },
        },
    }
    client.Applications.CreateApplication(
        context.TODO(),
        request,
    )
}

```

**`CreateApplicationForExistingPaypoint`**

```php CreateApplicationForExistingPaypoint
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\Applications\Requests\CreateApplicationRequest;
use Payabli\Types\RequestedServices;
use Payabli\Types\MoneyOutService;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->applications->createApplication(
    new CreateApplicationRequest([
        'businessReference' => '019fed1a-3d6e-75d3-a81e-cba3874b0a55',
        'paypointReference' => '019ff064-c690-7679-a73e-688418aadc7c',
        'externalId' => 'APP-2025-0418',
        'requestTemplate' => '019ff129-d393-7761-9a31-e5afe85b4081',
        'tags' => [
            'add-services',
        ],
        'services' => new RequestedServices([
            'moneyOut' => [
                MoneyOutService::Ach->value,
                MoneyOutService::Check->value,
            ],
        ]),
    ]),
);

```

**`CreateApplicationForExistingPaypoint`**

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

url = URI("https://api-sandbox.payabli.com/api/v2/requests")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"businessReference\": \"019fed1a-3d6e-75d3-a81e-cba3874b0a55\",\n  \"paypointReference\": \"019ff064-c690-7679-a73e-688418aadc7c\",\n  \"externalId\": \"APP-2025-0418\",\n  \"requestTemplate\": \"019ff129-d393-7761-9a31-e5afe85b4081\",\n  \"tags\": [\n    \"add-services\"\n  ],\n  \"services\": {\n    \"moneyOut\": [\n      \"Ach\",\n      \"Check\"\n    ]\n  }\n}"

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

**`CreateApplicationForExistingPaypoint`**

```swift CreateApplicationForExistingPaypoint
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "businessReference": "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
  "paypointReference": "019ff064-c690-7679-a73e-688418aadc7c",
  "externalId": "APP-2025-0418",
  "requestTemplate": "019ff129-d393-7761-9a31-e5afe85b4081",
  "tags": ["add-services"],
  "services": ["moneyOut": ["Ach", "Check"]]
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/requests")! 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()
```

The response returns the new application in `draft`, with the requested services:

### Response (201)

```json
{
  "success": true,
  "message": "Application created successfully",
  "traceId": "0HNONVRI1TBG9:00000029",
  "data": {
    "requestsReference": "4463979d-6336-4298-90cb-52d446030874",
    "businessReference": "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
    "applicationStatus": "draft",
    "applicationStatusCode": 1,
    "allowedActions": [
      "submit",
      "withdraw",
      "abandon"
    ],
    "createdAt": "2026-09-28T15:48:54.0628351Z",
    "_links": {
      "self": "/v2/requests/4463979d-6336-4298-90cb-52d446030874",
      "business": "/v2/businesses/019fed1a-3d6e-75d3-a81e-cba3874b0a55"
    },
    "paypointReference": "019ff064-c690-7679-a73e-688418aadc7c",
    "paypointStatus": "active",
    "externalId": "APP-2025-0418",
    "parent": "a8806f02-23b3-4f6d-bba3-42e1b94326ea",
    "parentOrgName": "PropertyManager Pro",
    "requestTemplate": "019ff129-d393-7761-9a31-e5afe85b4081",
    "services": {
      "moneyOut": [
        "Ach",
        "Check"
      ]
    },
    "tags": [
      "add-services"
    ]
  }
}
```

The `requestsReference` in the response identifies the new application.

## Choose the signer

Every application needs exactly one signer, and both validate and submit check for one. The signer must be an owner, flagged with `isSigner` on their link to the business. If the business doesn't have a signer yet, or the signer has changed, send a `PATCH` request to `/v2/businesses/{businessReference}/people/{personReference}` with `isSigner` set to `true`. Setting a new signer removes the flag from the person who had it. You can also choose the signer at submit with `signer.personReference`, but validate doesn't see that choice, so setting the flag first lets you validate the full application. See [Manage the people on a business](/guides/pay-ops-developer-businesses-manage#manage-the-people-on-a-business).

Payabli takes the signer's identity from their person record and business link when you submit, so check that their details are current.

## Validate the application

New services can require details that the paypoint's first boarding didn't, because different services have different requirements. Before you submit, check that the business, its people, and its payment methods have everything the new services need. Send a `POST` request to `/v2/requests/{requestsReference}/validate`. See the [API reference](/developers/api-reference/applications/validate-an-application) for this endpoint for full documentation.

### Request

POST [https://api-sandbox.payabli.com/api/v2/requests/\{requestsReference}/validate](https://api-sandbox.payabli.com/api/v2/requests/\{requestsReference}/validate)

**`ValidateApplication`**

```curl ValidateApplication
curl -X POST https://api-sandbox.payabli.com/api/v2/requests/4463979d-6336-4298-90cb-52d446030874/validate \
     -H "Authorization: Bearer <token>"
```

**`ValidateApplication`**

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

async function main() {
    const client = new PayabliClient({
        bearerAuth: {
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET",
        },
    });
    await client.applications.validateApplication("4463979d-6336-4298-90cb-52d446030874");
}
main();

```

**`ValidateApplication`**

```python ValidateApplication
from payabli import payabli

client = payabli(
    client_id="YOUR_CLIENT_ID",
    client_secret="YOUR_CLIENT_SECRET",
)

client.applications.validate_application(
    requests_reference="4463979d-6336-4298-90cb-52d446030874",
)

```

**`ValidateApplication`**

```java ValidateApplication
package com.example.usage;

import io.github.payabli.api.PayabliApiClient;

public class Example {
    public static void main(String[] args) {
        PayabliApiClient client = PayabliApiClient.withCredentials("YOUR_CLIENT_ID", "YOUR_CLIENT_SECRET")
            .build()
        ;

        client.applications().validateApplication("4463979d-6336-4298-90cb-52d446030874");
    }
}
```

**`ValidateApplication`**

```csharp ValidateApplication
using PayabliApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new PayabliApiClient(
            clientId: "YOUR_CLIENT_ID",
            clientSecret: "YOUR_CLIENT_SECRET"
        );

        await client.Applications.ValidateApplicationAsync(
            "4463979d-6336-4298-90cb-52d446030874"
        );
    }

}

```

**`ValidateApplication`**

```go ValidateApplication
package example

import (
    context "context"

    client "github.com/payabli/sdk-go/client"
    option "github.com/payabli/sdk-go/option"
)

func do() {
    client := client.NewClient(
        option.WithClientCredentials(
            "YOUR_CLIENT_ID",
            "YOUR_CLIENT_SECRET",
        ),
    )
    client.Applications.ValidateApplication(
        context.TODO(),
        "4463979d-6336-4298-90cb-52d446030874",
    )
}

```

**`ValidateApplication`**

```php ValidateApplication
<?php

namespace Example;

use Payabli\PayabliClient;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->applications->validateApplication(
    '4463979d-6336-4298-90cb-52d446030874',
);

```

**`ValidateApplication`**

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

url = URI("https://api-sandbox.payabli.com/api/v2/requests/4463979d-6336-4298-90cb-52d446030874/validate")

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

request = Net::HTTP::Post.new(url)
request["Authorization"] = 'Bearer <token>'

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

**`ValidateApplication`**

```swift ValidateApplication
import Foundation

let headers = ["Authorization": "Bearer <token>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/requests/4463979d-6336-4298-90cb-52d446030874/validate")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "POST"
request.allHTTPHeaderFields = headers

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

When `valid` is `true`, the records have everything the requested services need:

### Response (200)

```json
{
  "success": true,
  "message": "Validation completed",
  "traceId": "0HNONVRI1TD2T:00000012",
  "data": {
    "valid": true,
    "servicesEvaluated": [
      "payOutAch",
      "payOutCheck"
    ],
    "sections": {
      "business": {
        "complete": true,
        "missingFields": []
      },
      "salesAndPayments": {
        "complete": true,
        "missingFields": []
      },
      "banking": {
        "complete": true,
        "missingFields": []
      },
      "people": {
        "complete": true,
        "missingFields": []
      }
    }
  }
}
```

When `valid` is `false`, each section lists its `missingFields`. The `field` value is the path on the record to fix, such as `business.taxReference`. Update that record, such as with a `PATCH` request to the business, then validate again. If a `field` starts with `documents.`, it's a required document, not a record field: upload the file to the application instead. See [Upload documents](/guides/pay-ops-developer-applications-manage#upload-documents). `servicesEvaluated` names the requested services with Payabli's internal service names, such as `payInCard` for the `Card` Pay In service.

### Response (200)

```json
{
  "success": true,
  "message": "Validation completed",
  "traceId": "0HNONVR8FHN0R:00000017",
  "data": {
    "valid": false,
    "servicesEvaluated": [
      "payInCard",
      "payInAch"
    ],
    "sections": {
      "business": {
        "complete": false,
        "missingFields": [
          {
            "field": "business.description",
            "label": "Business Description",
            "reason": "required"
          },
          {
            "field": "business.legalStructure",
            "label": "Legal Structure",
            "reason": "required"
          },
          {
            "field": "business.establishedDate",
            "label": "Established Date",
            "reason": "required"
          },
          {
            "field": "business.incorporationState",
            "label": "Formation State",
            "reason": "required"
          },
          {
            "field": "business.merchantCatCode",
            "label": "Industry (MCC)",
            "reason": "required"
          },
          {
            "field": "business.taxReference",
            "label": "Tax ID (EIN/SSN)",
            "reason": "required"
          },
          {
            "field": "business.taxIdCountry",
            "label": "Tax ID Country",
            "reason": "required"
          },
          {
            "field": "business.isForeignOwned",
            "label": "Foreign Owned",
            "reason": "required"
          },
          {
            "field": "business.operatingSeasons",
            "label": "Operating Seasons",
            "reason": "required"
          },
          {
            "field": "business.phone",
            "label": "Business Phone",
            "reason": "required"
          },
          {
            "field": "business.emails",
            "label": "Business Email",
            "reason": "required"
          },
          {
            "field": "business.addressDetails",
            "label": "Business Address",
            "reason": "required"
          }
        ]
      },
      "salesAndPayments": {
        "complete": false,
        "missingFields": [
          {
            "field": "business.processingMetrics.monthlyReceivablesVolume",
            "label": "Annual Payment Volume",
            "reason": "required"
          },
          {
            "field": "business.processingMetrics.largestReceivableSize",
            "label": "Largest Transaction",
            "reason": "required"
          },
          {
            "field": "business.processingMetrics.environments",
            "label": "Payment Environment",
            "reason": "required"
          },
          {
            "field": "business.processingMetrics.numberOfTransactions",
            "label": "Monthly Payment Count",
            "reason": "required"
          }
        ]
      },
      "banking": {
        "complete": false,
        "missingFields": [
          {
            "field": "paymentMethods",
            "label": "At least one payment method is required",
            "reason": "required"
          }
        ]
      },
      "people": {
        "complete": false,
        "missingFields": [
          {
            "field": "people",
            "label": "At least one owner or officer is required",
            "reason": "required"
          }
        ]
      }
    }
  }
}
```

## Submit the application

Send a `POST` request to `/v2/requests/{requestsReference}/submit` with the new application's `requestsReference`, and include a `signer` with the signature details. See [Submit an application](/guides/pay-ops-developer-applications-manage#submit-an-application) for the request and response.

After you submit the application, it moves through review. To answer underwriting, see [Respond to underwriting requests](/guides/pay-ops-developer-applications-manage#respond-to-underwriting-requests). To follow the application's progress, see [Track status changes](/guides/pay-ops-developer-applications-manage#track-status-changes).

## Related resources

See these related resources to help you get the most out of Payabli.

#### References

* **[Required fields for boarding applications](/guides/pay-ops-boarding-kyc-fields-overview)** - Learn more about the Know Your Customer (KYC) and Know Your Business (KYB) fields required for merchant boarding

#### Related topics

* **[Manage applications with the API](/guides/pay-ops-developer-applications-manage)** - Learn how to create, submit, and track boarding applications with the Payabli API
* **[Manage paypoints with the API](/guides/pay-ops-developer-boarding-paypoints-manage)** - Learn how to create, read, update, and list boarding paypoints with the Payabli API