> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.tabs.com/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.tabs.com/_mcp/server.

# List customer payment accounts

GET https://integrators.prod.api.tabsplatform.com/v3/customers/{id}/payment-accounts

Returns the payment-processor accounts this customer is linked to — the processor's own customer reference, the default payment method Tabs has on record, and whether that processor is your merchant account's default.

A customer can be linked on more than one processor at a time, so this always returns a list. It is empty when the customer is not linked anywhere.

Filter with `processorType` to ask about one processor, or `onlyDefault=true` for just your merchant account's default processor. Either filter returns the link even if that processor is not finished setting up on your merchant account; the unfiltered list only covers processors that are ready to charge.

Reference: https://docs.tabs.com/api-reference/payment-accounts/integrators-api-customer-payment-accounts-controller-v-3-get-customer-payment-accounts

## Authentication

- `Authorization` header (required)

## Request

### Path parameters

- `id` (string, required) — Customer Id

### Query parameters

- `processorType` (enum, optional) — Return only the account on this processor. `STRIPE` is the only supported value. Omit to return every processor the customer is linked on.
  - Allowed values: `STRIPE`
- `onlyDefault` (boolean, optional) — Return only the account on your merchant account's default processor.

## Response

### 200

The customer's payment accounts, filtered by the supplied query.

- `payload` (object, required) — Response payload, will be empty when success is false
  - `items` (list of object, required) — The customer's payment accounts. Empty when the customer is not linked to any processor.
    - `processorType` (enum, required) — Processor the account lives on.
      - Allowed values: `STRIPE`
    - `processorCustomerRef` (string, required) — The processor's own customer identifier — for Stripe, the `cus_…` id.
    - `defaultPaymentMethod` (string, required, nullable) — Default payment method Tabs has on record for this account, or `null` if there is none.
    - `defaultPaymentMethodType` (enum, required, nullable) — Type of `defaultPaymentMethod`.
      - Allowed values: `CREDIT_CARD`, `ACH_DEBIT`, `ACH_CREDIT`, `CHECK`, `LINK`
    - `isDefaultProcessor` (boolean, required) — Whether this processor is your merchant account's default.
- `success` (boolean, required) — Boolean with true=success, false=failure
- `message` (string, required) — Plain-text description of the result
- `error` (object, optional) — json element with any error messages or warnings
  - `code` (double, required) — API response code
  - `message` (string, required) — API response message
  - `details` (object, optional) — Additional details about the error

## Examples

**Response**

```json
{
  "payload": {
    "items": [
      {
        "processorType": "STRIPE",
        "processorCustomerRef": "cus_NffrFeUfNV2Hib",
        "defaultPaymentMethod": "pm_1MqLiJLkdIwHu7ixUEgbFdYF",
        "defaultPaymentMethodType": "CREDIT_CARD",
        "isDefaultProcessor": true
      }
    ]
  },
  "success": true,
  "message": "string",
  "error": {
    "code": 1.1,
    "message": "string",
    "details": {}
  }
}
```

**SDK Code**

```python
import requests

url = "https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts"

headers = {"Authorization": "<apiKey>"}

response = requests.get(url, headers=headers)

print(response.json())
```

```javascript
const url = 'https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts';
const options = {method: 'GET', headers: {Authorization: '<apiKey>'}};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

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

func main() {

	url := "https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Authorization", "<apiKey>")

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

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

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

}
```

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

url = URI("https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts")

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

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

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

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

HttpResponse<String> response = Unirest.get("https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts")
  .header("Authorization", "<apiKey>")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts', [
  'headers' => [
    'Authorization' => '<apiKey>',
  ],
]);

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

```csharp
using RestSharp;

var client = new RestClient("https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "<apiKey>");
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = ["Authorization": "<apiKey>"]

let request = NSMutableURLRequest(url: NSURL(string: "https://integrators.prod.api.tabsplatform.com/v3/customers/123e4567-e89b-12d3-a456-426614174000/payment-accounts")! 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()
```