> 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

# Manage paypoints with the API

> Learn how to create, read, update, and list boarding paypoints with the Payabli API

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

A paypoint is the entity that moves money for a business. A paypoint set up for Pay In is a merchant, but it can also be set up for Pay Out, or both. A business can have many paypoints, each with its own status and settings. Use the paypoints API to create and manage them as part of boarding. For how paypoints fit into the wider model, see the [boarding overview](/guides/pay-ops-boarding-object-model-overview).

## Considerations

* The boarding API uses OAuth2. Send a Bearer token on every request. See [OAuth2 authentication](/developers/oauth-authentication).
* A paypoint boards under a business. Provide either a `businessReference` for an existing business, or a `business` object to create one inline.

## Create a paypoint

Send a `POST` request to `/v2/paypoints` with the paypoint's `doingBusinessAs` and the business it boards under. Provide either a `businessReference` for an existing business, or a `business` object to create one inline. New paypoints start in `pending`. See the [API reference](/developers/api-reference/paypoints/create-a-paypoint) for this endpoint for full documentation.

### Request

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

**`CreatePaypoint`**

```curl CreatePaypoint
curl -X POST https://api-sandbox.payabli.com/api/v2/paypoints \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "businessReference": "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
  "customerServiceEmail": "support@example.com",
  "customerServicePhone": "3055551212",
  "description": "Boutique flower shop",
  "doingBusinessAs": "Rose Gardens",
  "paypointType": "merchant",
  "timezone": "America/New_York",
  "website": "https://example.com"
}'
```

**`CreatePaypoint`**

```typescript CreatePaypoint
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.createPaypoint({
        paypointType: "merchant",
        doingBusinessAs: "Rose Gardens",
        description: "Boutique flower shop",
        website: "https://example.com",
        customerServicePhone: "3055551212",
        customerServiceEmail: "support@example.com",
        timezone: "America/New_York",
        businessReference: "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
    });
}
main();

```

**`CreatePaypoint`**

```python CreatePaypoint
from payabli import payabli, CreatePaypointWithBusinessReference

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

client.paypoints.create_paypoint(
    request=CreatePaypointWithBusinessReference(
        paypoint_type="merchant",
        doing_business_as="Rose Gardens",
        description="Boutique flower shop",
        website="https://example.com",
        customer_service_phone="3055551212",
        customer_service_email="support@example.com",
        timezone="America/New_York",
        business_reference="019fed1a-3d6e-75d3-a81e-cba3874b0a55",
    ),
)

```

**`CreatePaypoint`**

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.paypoints.types.CreatePaypointPaypointsRequest;
import io.github.payabli.api.types.CreatePaypointWithBusinessReference;
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.paypoints().createPaypoint(
            CreatePaypointPaypointsRequest.of(
                CreatePaypointWithBusinessReference
                    .builder()
                    .doingBusinessAs("Rose Gardens")
                    .businessReference("019fed1a-3d6e-75d3-a81e-cba3874b0a55")
                    .paypointType(Optional.of("merchant"))
                    .description(Optional.of("Boutique flower shop"))
                    .website(Optional.of("https://example.com"))
                    .customerServicePhone(Optional.of("3055551212"))
                    .customerServiceEmail(Optional.of("support@example.com"))
                    .timezone(Optional.of("America/New_York"))
                    .build()
            )
        );
    }
}
```

**`CreatePaypoint`**

```csharp CreatePaypoint
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.CreatePaypointAsync(
            new CreatePaypointWithBusinessReference {
                PaypointType = "merchant",
                DoingBusinessAs = "Rose Gardens",
                Description = "Boutique flower shop",
                Website = "https://example.com",
                CustomerServicePhone = "3055551212",
                CustomerServiceEmail = "support@example.com",
                Timezone = "America/New_York",
                BusinessReference = "019fed1a-3d6e-75d3-a81e-cba3874b0a55"
            }
        );
    }

}

```

**`CreatePaypoint`**

```go CreatePaypoint
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.CreatePaypointPaypointsRequest{
        CreatePaypointWithBusinessReference: &payabli.CreatePaypointWithBusinessReference{
            BusinessReference: "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
            CustomerServiceEmail: payabli.String(
                "support@example.com",
            ),
            CustomerServicePhone: payabli.String(
                "3055551212",
            ),
            Description: payabli.String(
                "Boutique flower shop",
            ),
            DoingBusinessAs: "Rose Gardens",
            PaypointType: payabli.String(
                "merchant",
            ),
            Timezone: payabli.String(
                "America/New_York",
            ),
            Website: payabli.String(
                "https://example.com",
            ),
        },
    }
    client.Paypoints.CreatePaypoint(
        context.TODO(),
        request,
    )
}

```

**`CreatePaypoint`**

```php CreatePaypoint
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\Types\CreatePaypointWithBusinessReference;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->paypoints->createPaypoint(
    new CreatePaypointWithBusinessReference([
        'paypointType' => 'merchant',
        'doingBusinessAs' => 'Rose Gardens',
        'description' => 'Boutique flower shop',
        'website' => 'https://example.com',
        'customerServicePhone' => '3055551212',
        'customerServiceEmail' => 'support@example.com',
        'timezone' => 'America/New_York',
        'businessReference' => '019fed1a-3d6e-75d3-a81e-cba3874b0a55',
    ]),
);

```

**`CreatePaypoint`**

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

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

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  \"customerServiceEmail\": \"support@example.com\",\n  \"customerServicePhone\": \"3055551212\",\n  \"description\": \"Boutique flower shop\",\n  \"doingBusinessAs\": \"Rose Gardens\",\n  \"paypointType\": \"merchant\",\n  \"timezone\": \"America/New_York\",\n  \"website\": \"https://example.com\"\n}"

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

**`CreatePaypoint`**

```swift CreatePaypoint
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "businessReference": "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
  "customerServiceEmail": "support@example.com",
  "customerServicePhone": "3055551212",
  "description": "Boutique flower shop",
  "doingBusinessAs": "Rose Gardens",
  "paypointType": "merchant",
  "timezone": "America/New_York",
  "website": "https://example.com"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/paypoints")! 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 paypoint's reference and initial status:

### Response (201)

```json
{
  "success": true,
  "message": "Paypoint created successfully",
  "traceId": "0HNNN6HH5NDB3:00000001",
  "data": {
    "paypointReference": "019ff064-c690-7679-a73e-688418aadc7c",
    "paypointStatus": "pending",
    "createdAt": "2026-08-11T10:36:04.1157718Z",
    "_links": {
      "self": "/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c",
      "business": "/v2/businesses/019fed1a-3d6e-75d3-a81e-cba3874b0a55"
    },
    "businessReference": "019fed1a-3d6e-75d3-a81e-cba3874b0a55",
    "doingBusinessAs": "Rose Gardens",
    "timezone": "America/New_York"
  }
}
```

To create the business inline instead, send a `business` object rather than a `businessReference`:

### Request

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

**`CreatePaypointInlineBusiness`**

```curl CreatePaypointInlineBusiness
curl -X POST https://api-sandbox.payabli.com/api/v2/paypoints \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "business": {
    "emails": [
      "ops@example.com"
    ],
    "externalId": "rg-001",
    "legalName": "Rose Gardens LLC",
    "legalStructure": "llc",
    "merchantCatCode": "5814",
    "parentReference": "8cfec329267",
    "phone": [
      "3055551212"
    ],
    "taxReference": "477498993",
    "website": "https://example.com"
  },
  "customerServiceEmail": "support@example.com",
  "customerServicePhone": "3055551212",
  "description": "Boutique flower shop",
  "doingBusinessAs": "Rose Gardens",
  "paypointType": "merchant",
  "timezone": "America/New_York",
  "website": "https://example.com"
}'
```

**`CreatePaypointInlineBusiness`**

```typescript CreatePaypointInlineBusiness
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.createPaypoint({
        paypointType: "merchant",
        doingBusinessAs: "Rose Gardens",
        description: "Boutique flower shop",
        website: "https://example.com",
        customerServicePhone: "3055551212",
        customerServiceEmail: "support@example.com",
        timezone: "America/New_York",
        business: {
            externalId: "rg-001",
            legalName: "Rose Gardens LLC",
            legalStructure: "llc",
            website: "https://example.com",
            merchantCatCode: "5814",
            phone: [
                "3055551212",
            ],
            emails: [
                "ops@example.com",
            ],
            taxReference: "477498993",
            parentReference: "8cfec329267",
        },
    });
}
main();

```

**`CreatePaypointInlineBusiness`**

```python CreatePaypointInlineBusiness
from payabli import payabli, CreatePaypointWithInlineBusiness, CreateBusinessRequest

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

client.paypoints.create_paypoint(
    request=CreatePaypointWithInlineBusiness(
        paypoint_type="merchant",
        doing_business_as="Rose Gardens",
        description="Boutique flower shop",
        website="https://example.com",
        customer_service_phone="3055551212",
        customer_service_email="support@example.com",
        timezone="America/New_York",
        business=CreateBusinessRequest(
            external_id="rg-001",
            legal_name="Rose Gardens LLC",
            legal_structure="llc",
            website="https://example.com",
            merchant_cat_code="5814",
            phone=[
                "3055551212"
            ],
            emails=[
                "ops@example.com"
            ],
            tax_reference="477498993",
            parent_reference="8cfec329267",
        ),
    ),
)

```

**`CreatePaypointInlineBusiness`**

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

import io.github.payabli.api.PayabliApiClient;
import io.github.payabli.api.resources.paypoints.types.CreatePaypointPaypointsRequest;
import io.github.payabli.api.types.CreateBusinessRequest;
import io.github.payabli.api.types.CreateBusinessRequestLegalStructure;
import io.github.payabli.api.types.CreatePaypointWithInlineBusiness;
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.paypoints().createPaypoint(
            CreatePaypointPaypointsRequest.of(
                CreatePaypointWithInlineBusiness
                    .builder()
                    .doingBusinessAs("Rose Gardens")
                    .business(
                        CreateBusinessRequest
                            .builder()
                            .legalName("Rose Gardens LLC")
                            .externalId(Optional.of("rg-001"))
                            .legalStructure(Optional.of(CreateBusinessRequestLegalStructure.LLC))
                            .website(Optional.of("https://example.com"))
                            .merchantCatCode(Optional.of("5814"))
                            .phone(
                                Optional.of(
                                    Arrays.asList("3055551212")
                                )
                            )
                            .emails(
                                Optional.of(
                                    Arrays.asList("ops@example.com")
                                )
                            )
                            .taxReference(Optional.of("477498993"))
                            .parentReference(Optional.of("8cfec329267"))
                            .build()
                    )
                    .paypointType(Optional.of("merchant"))
                    .description(Optional.of("Boutique flower shop"))
                    .website(Optional.of("https://example.com"))
                    .customerServicePhone(Optional.of("3055551212"))
                    .customerServiceEmail(Optional.of("support@example.com"))
                    .timezone(Optional.of("America/New_York"))
                    .build()
            )
        );
    }
}
```

**`CreatePaypointInlineBusiness`**

```csharp CreatePaypointInlineBusiness
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.Paypoints.CreatePaypointAsync(
            new CreatePaypointWithInlineBusiness {
                PaypointType = "merchant",
                DoingBusinessAs = "Rose Gardens",
                Description = "Boutique flower shop",
                Website = "https://example.com",
                CustomerServicePhone = "3055551212",
                CustomerServiceEmail = "support@example.com",
                Timezone = "America/New_York",
                Business = new CreateBusinessRequest {
                    ExternalId = "rg-001",
                    LegalName = "Rose Gardens LLC",
                    LegalStructure = CreateBusinessRequestLegalStructure.Llc,
                    Website = "https://example.com",
                    MerchantCatCode = "5814",
                    Phone = new List<string>(){
                        "3055551212",
                    }
                    ,
                    Emails = new List<string>(){
                        "ops@example.com",
                    }
                    ,
                    TaxReference = "477498993",
                    ParentReference = "8cfec329267"
                }
            }
        );
    }

}

```

**`CreatePaypointInlineBusiness`**

```go CreatePaypointInlineBusiness
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.CreatePaypointPaypointsRequest{
        CreatePaypointWithInlineBusiness: &payabli.CreatePaypointWithInlineBusiness{
            Business: &payabli.CreateBusinessRequest{
                Emails: []string{
                    "ops@example.com",
                },
                ExternalId: payabli.String(
                    "rg-001",
                ),
                LegalName: "Rose Gardens LLC",
                LegalStructure: payabli.CreateBusinessRequestLegalStructureLlc.Ptr(),
                MerchantCatCode: payabli.String(
                    "5814",
                ),
                ParentReference: payabli.String(
                    "8cfec329267",
                ),
                Phone: []string{
                    "3055551212",
                },
                TaxReference: payabli.String(
                    "477498993",
                ),
                Website: payabli.String(
                    "https://example.com",
                ),
            },
            CustomerServiceEmail: payabli.String(
                "support@example.com",
            ),
            CustomerServicePhone: payabli.String(
                "3055551212",
            ),
            Description: payabli.String(
                "Boutique flower shop",
            ),
            DoingBusinessAs: "Rose Gardens",
            PaypointType: payabli.String(
                "merchant",
            ),
            Timezone: payabli.String(
                "America/New_York",
            ),
            Website: payabli.String(
                "https://example.com",
            ),
        },
    }
    client.Paypoints.CreatePaypoint(
        context.TODO(),
        request,
    )
}

```

**`CreatePaypointInlineBusiness`**

```php CreatePaypointInlineBusiness
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\Types\CreatePaypointWithBusinessReference;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->paypoints->createPaypoint(
    new CreatePaypointWithBusinessReference([
        'paypointType' => 'merchant',
        'doingBusinessAs' => 'Rose Gardens',
        'description' => 'Boutique flower shop',
        'website' => 'https://example.com',
        'customerServicePhone' => '3055551212',
        'customerServiceEmail' => 'support@example.com',
        'timezone' => 'America/New_York',
        'businessReference' => 'value',
    ]),
);

```

**`CreatePaypointInlineBusiness`**

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

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

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  \"business\": {\n    \"emails\": [\n      \"ops@example.com\"\n    ],\n    \"externalId\": \"rg-001\",\n    \"legalName\": \"Rose Gardens LLC\",\n    \"legalStructure\": \"llc\",\n    \"merchantCatCode\": \"5814\",\n    \"parentReference\": \"8cfec329267\",\n    \"phone\": [\n      \"3055551212\"\n    ],\n    \"taxReference\": \"477498993\",\n    \"website\": \"https://example.com\"\n  },\n  \"customerServiceEmail\": \"support@example.com\",\n  \"customerServicePhone\": \"3055551212\",\n  \"description\": \"Boutique flower shop\",\n  \"doingBusinessAs\": \"Rose Gardens\",\n  \"paypointType\": \"merchant\",\n  \"timezone\": \"America/New_York\",\n  \"website\": \"https://example.com\"\n}"

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

**`CreatePaypointInlineBusiness`**

```swift CreatePaypointInlineBusiness
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [
  "business": [
    "emails": ["ops@example.com"],
    "externalId": "rg-001",
    "legalName": "Rose Gardens LLC",
    "legalStructure": "llc",
    "merchantCatCode": "5814",
    "parentReference": "8cfec329267",
    "phone": ["3055551212"],
    "taxReference": "477498993",
    "website": "https://example.com"
  ],
  "customerServiceEmail": "support@example.com",
  "customerServicePhone": "3055551212",
  "description": "Boutique flower shop",
  "doingBusinessAs": "Rose Gardens",
  "paypointType": "merchant",
  "timezone": "America/New_York",
  "website": "https://example.com"
] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/paypoints")! 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 `paypointReference` in the response is the reference you use to read and manage the paypoint.

## Get a paypoint

Send a `GET` request to `/v2/paypoints/{paypointReference}`. See the [API reference](/developers/api-reference/paypoints/get-a-paypoint) for this endpoint for full documentation.

### Request

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

```curl
curl https://api-sandbox.payabli.com/api/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c \
     -H "Authorization: Bearer <token>"
```

```typescript
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.getPaypoint("019ff064-c690-7679-a73e-688418aadc7c");
}
main();

```

```python
from payabli import payabli

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

client.paypoints.get_paypoint(
    paypoint_reference="019ff064-c690-7679-a73e-688418aadc7c",
)

```

```java
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.paypoints().getPaypoint("019ff064-c690-7679-a73e-688418aadc7c");
    }
}
```

```csharp
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.GetPaypointAsync(
            "019ff064-c690-7679-a73e-688418aadc7c"
        );
    }

}

```

```go
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.Paypoints.GetPaypoint(
        context.TODO(),
        "019ff064-c690-7679-a73e-688418aadc7c",
    )
}

```

```php
<?php

namespace Example;

use Payabli\PayabliClient;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->paypoints->getPaypoint(
    '019ff064-c690-7679-a73e-688418aadc7c',
);

```

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

url = URI("https://api-sandbox.payabli.com/api/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c")

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

```swift
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c")! 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 returns the paypoint's full detail:

### Response (200)

```json
{
  "success": true,
  "message": "Paypoint retrieved successfully",
  "traceId": "0HNNN6HH5NDB3:00000002",
  "data": {
    "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",
    "description": "Boutique flower shop",
    "website": "https://example.com",
    "timezone": "America/New_York",
    "customerServicePhone": "3055551212",
    "customerServiceEmail": "support@example.com"
  }
}
```

## List paypoints

Send a `GET` request to `/v2/paypoints`. Filter and page the results with the query parameters: `businessReference`, `status`, `search`, `limit`, and `page`. 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)

**`ListPaypoints`**

```curl ListPaypoints
curl -G https://api-sandbox.payabli.com/api/v2/paypoints \
     -H "Authorization: Bearer <token>" \
     -d limit=1 \
     -d page=1
```

**`ListPaypoints`**

```typescript ListPaypoints
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({
        limit: 1,
        page: 1,
    });
}
main();

```

**`ListPaypoints`**

```python ListPaypoints
from payabli import payabli

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

client.paypoints.list_paypoints(
    limit=1,
    page=1,
)

```

**`ListPaypoints`**

```java ListPaypoints
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()
                .limit(1)
                .page(1)
                .build()
        );
    }
}
```

**`ListPaypoints`**

```csharp ListPaypoints
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 {
                Limit = 1,
                Page = 1
            }
        );
    }

}

```

**`ListPaypoints`**

```go ListPaypoints
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{
        Limit: payabli.Int(
            1,
        ),
        Page: payabli.Int(
            1,
        ),
    }
    client.Paypoints.ListPaypoints(
        context.TODO(),
        request,
    )
}

```

**`ListPaypoints`**

```php ListPaypoints
<?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([
        'limit' => 1,
        'page' => 1,
    ]),
);

```

**`ListPaypoints`**

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

url = URI("https://api-sandbox.payabli.com/api/v2/paypoints?limit=1&page=1")

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

**`ListPaypoints`**

```swift ListPaypoints
import Foundation

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/paypoints?limit=1&page=1")! 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 returns a page of paypoints with pagination metadata:

### Response (200)

```json
{
  "success": true,
  "message": "Paypoints retrieved successfully",
  "traceId": "0HNNN6HH5NDBG:00000018",
  "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",
        "description": "Boutique flower shop",
        "website": "https://example.com",
        "timezone": "America/New_York",
        "customerServicePhone": "3055551212",
        "customerServiceEmail": "support@example.com"
      }
    ],
    "total": 1,
    "page": 1,
    "pageSize": 1
  }
}
```

## Update a paypoint

Send a `PATCH` request to `/v2/paypoints/{paypointReference}` with only the fields you want to change. See the [API reference](/developers/api-reference/paypoints/update-a-paypoint) for this endpoint for full documentation.

### Request

PATCH [https://api-sandbox.payabli.com/api/v2/paypoints/\{paypointReference}](https://api-sandbox.payabli.com/api/v2/paypoints/\{paypointReference})

```curl
curl -X PATCH https://api-sandbox.payabli.com/api/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c \
     -H "Authorization: Bearer <token>" \
     -H "Content-Type: application/json" \
     -d '{
  "description": "Updated description"
}'
```

```typescript
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.updatePaypoint("019ff064-c690-7679-a73e-688418aadc7c", {
        description: "Updated description",
    });
}
main();

```

```python
from payabli import payabli

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

client.paypoints.update_paypoint(
    paypoint_reference="019ff064-c690-7679-a73e-688418aadc7c",
    description="Updated description",
)

```

```java
package com.example.usage;

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

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

        client.paypoints().updatePaypoint(
            "019ff064-c690-7679-a73e-688418aadc7c",
            UpdatePaypointRequest
                .builder()
                .description("Updated description")
                .build()
        );
    }
}
```

```csharp
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.UpdatePaypointAsync(
            paypointReference: "019ff064-c690-7679-a73e-688418aadc7c",
            request: new UpdatePaypointRequest {
                Description = "Updated description"
            }
        );
    }

}

```

```go
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.UpdatePaypointRequest{
        Description: payabli.String(
            "Updated description",
        ),
    }
    client.Paypoints.UpdatePaypoint(
        context.TODO(),
        "019ff064-c690-7679-a73e-688418aadc7c",
        request,
    )
}

```

```php
<?php

namespace Example;

use Payabli\PayabliClient;
use Payabli\Paypoints\Requests\UpdatePaypointRequest;

$client = new PayabliClient(
    clientId: 'YOUR_CLIENT_ID',
    clientSecret: 'YOUR_CLIENT_SECRET',
);
$client->paypoints->updatePaypoint(
    '019ff064-c690-7679-a73e-688418aadc7c',
    new UpdatePaypointRequest([
        'description' => 'Updated description',
    ]),
);

```

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

url = URI("https://api-sandbox.payabli.com/api/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c")

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

request = Net::HTTP::Patch.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{\n  \"description\": \"Updated description\"\n}"

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

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = ["description": "Updated description"] as [String : Any]

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

let request = NSMutableURLRequest(url: NSURL(string: "https://api-sandbox.payabli.com/api/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "PATCH"
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 confirms the update and returns the new timestamp:

### Response (200)

```json
{
  "success": true,
  "message": "Paypoint updated successfully",
  "traceId": "0HNNN6HH5ND71:00000268",
  "data": {
    "paypointReference": "019ff064-c690-7679-a73e-688418aadc7c",
    "updatedAt": "2026-08-11T10:36:04.462751Z",
    "_links": {
      "self": "/v2/paypoints/019ff064-c690-7679-a73e-688418aadc7c"
    }
  }
}
```

## 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
* **[Bank account functions and account IDs](/guides/pay-ops-boarding-bank-accounts-overview)** - Understand how deposit, withdrawal, and remittance accounts work and how account IDs route transactions

#### Related topics

* **[Intelligent boarding overview](/guides/pay-ops-boarding-object-model-overview)** - Understand the objects and application lifecycle behind intelligent boarding paypoints on Payabli
* **[Decision guide: Merchant boarding](/guides/pay-ops-boarding-decision)** - Choose how your platform boards merchants with intelligent boarding