# 

## Prerequisites

* A valid API key — see [Obtain API credentials](/docs/how-tos/setup/obtain-credentials)


## Batch reporting endpoints

| Endpoint | Method | Description |
|  --- | --- | --- |
| `/v1/batches` | GET | List batches with pagination, sorting, and filtering |
| `/v1/batches/status` | GET | Check settlement status of batches |


## Option A: List batches

Send `GET /v1/batches` to retrieve a paginated list of batches.

### Query parameters

| Parameter | Type | Description |
|  --- | --- | --- |
| `skip` | string | Number of records to skip (offset) |
| `take` | string | Number of records to return per page |
| `sort_column` | string | Column to sort by |
| `sort_order` | string | `asc` or `desc` |
| `search_text` | string | Free-text search |
| `term` | string | Filter term |


curl
```shell
curl -G \
  https://api.dev.paradisegateway.net/v1/batches \
  -H "APIKEY: YOUR-API-KEY" \
  -d skip=0 \
  -d take=10 \
  -d sort_order=desc
```

Python
```python
import requests

resp = requests.get(
    "https://api.dev.paradisegateway.net/v1/batches",
    headers={"APIKEY": "YOUR-API-KEY"},
    params={"skip": "0", "take": "10", "sort_order": "desc"},
)
data = resp.json()
print(f"Total batches: {data['count']}")
for batch in data["results"]:
    print(f"  {batch['batch_id']} — {batch['status']} — net: {batch['batch_net_amount']}")
```

JavaScript
```javascript
const params = new URLSearchParams({ skip: "0", take: "10", sort_order: "desc" });
const resp = await fetch(
  `https://api.dev.paradisegateway.net/v1/batches?${params}`,
  { headers: { "APIKEY": "YOUR-API-KEY" } }
);
const data = await resp.json();
console.log(`Total batches: ${data.count}`);
data.results.forEach((b) =>
  console.log(`  ${b.batch_id} — ${b.status} — net: ${b.batch_net_amount}`)
);
```

C#
```csharp
using var client = new HttpClient();
client.DefaultRequestHeaders.Add("APIKEY", "YOUR-API-KEY");
var resp = await client.GetAsync(
    "https://api.dev.paradisegateway.net/v1/batches?skip=0&take=10&sort_order=desc");
Console.WriteLine(await resp.Content.ReadAsStringAsync());
```

Java
```java
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create(
        "https://api.dev.paradisegateway.net/v1/batches?skip=0&take=10&sort_order=desc"))
    .header("APIKEY", "YOUR-API-KEY")
    .GET().build();
HttpResponse<String> resp = client.send(request,
    HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());
```

Go
```go
req, _ := http.NewRequest("GET",
    "https://api.dev.paradisegateway.net/v1/batches?skip=0&take=10&sort_order=desc", nil)
req.Header.Set("APIKEY", "YOUR-API-KEY")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
```

PHP
```php
$ch = curl_init("https://api.dev.paradisegateway.net/v1/batches?skip=0&take=10&sort_order=desc");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["APIKEY: YOUR-API-KEY"],
]);
echo curl_exec($ch); curl_close($ch);
```

Ruby
```ruby
require "net/http"
uri = URI("https://api.dev.paradisegateway.net/v1/batches?skip=0&take=10&sort_order=desc")
req = Net::HTTP::Get.new(uri, { "APIKEY" => "YOUR-API-KEY" })
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
puts resp.body
```

### Response

```json
{
  "count": 47,
  "results": [
    {
      "id": "BATCH-01KFDKXMQ637EKEAY410MSQSXB",
      "batch_id": "BATCH-01KFDKXMQ637EKEAY410MSQSXB",
      "batch_number": "001",
      "batch_type": "card",
      "processor": "tsys",
      "status": "settled",
      "client_id": "CLIENT-3MtwBwLkdIwHu7ix28a3tqPa",
      "client_name": "Acme Jewelry",
      "approved_amount": 125000,
      "captured_amount": 125000,
      "refund_amount": 2500,
      "void_amount": 0,
      "net_amount": 122500,
      "batch_net_amount": 122500,
      "created_at": "2026-03-24T00:00:00Z",
      "closed_at_date_time": "2026-03-24T22:00:00Z",
      "settled_at_date_time": "2026-03-25T06:00:00Z"
    }
  ],
  "correlation_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}
```

### Key batch fields

| Field | Description |
|  --- | --- |
| `status` | Current batch state (for example, `open`, `closed`, `settled`) |
| `approved_amount` | Total approved amount in the batch (minor units) |
| `captured_amount` | Total captured amount |
| `refund_amount` | Total refunds in the batch |
| `void_amount` | Total voids in the batch |
| `batch_net_amount` | Net settlement amount (`captured - refunds - voids`) |
| `closed_at_date_time` | When the batch was closed |
| `settled_at_date_time` | When funds were settled |


## Option B: Check batch settlement status

Send `GET /v1/batches/status` to check which batches are in progress and which have completed.

### Query parameters in batch settlement status

| Parameter | Type | Description |
|  --- | --- | --- |
| `client_id` | string | Filter by client |
| `last_checked_at` | date-time | Only return batches updated after this timestamp |


curl
```shell
curl -G \
  https://api.dev.paradisegateway.net/v1/batches/status \
  -H "APIKEY: YOUR-API-KEY" \
  -d last_checked_at=2026-03-24T00:00:00Z
```

Python
```python
resp = requests.get(
    "https://api.dev.paradisegateway.net/v1/batches/status",
    headers={"APIKEY": "YOUR-API-KEY"},
    params={"last_checked_at": "2026-03-24T00:00:00Z"},
)
data = resp.json()
print(f"Has in-progress: {data['has_in_progress']}")
print(f"In-progress batches: {len(data.get('in_progress_batches', []))}")
print(f"Completed batches: {len(data.get('completed_batches', []))}")
```

JavaScript
```javascript
const resp = await fetch(
  "https://api.dev.paradisegateway.net/v1/batches/status?last_checked_at=2026-03-24T00:00:00Z",
  { headers: { "APIKEY": "YOUR-API-KEY" } }
);
const data = await resp.json();
console.log("Has in-progress:", data.has_in_progress);
```

C#
```csharp
var resp = await client.GetAsync(
    "https://api.dev.paradisegateway.net/v1/batches/status?last_checked_at=2026-03-24T00:00:00Z");
Console.WriteLine(await resp.Content.ReadAsStringAsync());
```

Java
```java
HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create(
        "https://api.dev.paradisegateway.net/v1/batches/status?last_checked_at=2026-03-24T00:00:00Z"))
    .header("APIKEY", "YOUR-API-KEY")
    .GET().build();
HttpResponse<String> resp = client.send(request,
    HttpResponse.BodyHandlers.ofString());
System.out.println(resp.body());
```

Go
```go
req, _ := http.NewRequest("GET",
    "https://api.dev.paradisegateway.net/v1/batches/status?last_checked_at=2026-03-24T00:00:00Z", nil)
req.Header.Set("APIKEY", "YOUR-API-KEY")
resp, _ := http.DefaultClient.Do(req)
defer resp.Body.Close()
body, _ := io.ReadAll(resp.Body)
fmt.Println(string(body))
```

PHP
```php
$ch = curl_init("https://api.dev.paradisegateway.net/v1/batches/status?last_checked_at=2026-03-24T00:00:00Z");
curl_setopt_array($ch, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_HTTPHEADER => ["APIKEY: YOUR-API-KEY"],
]);
echo curl_exec($ch); curl_close($ch);
```

Ruby
```ruby
uri = URI("https://api.dev.paradisegateway.net/v1/batches/status?last_checked_at=2026-03-24T00:00:00Z")
req = Net::HTTP::Get.new(uri, { "APIKEY" => "YOUR-API-KEY" })
resp = Net::HTTP.start(uri.hostname, uri.port, use_ssl: true) { |http| http.request(req) }
puts resp.body
```

### Response in batch settlement status

```json
{
  "has_in_progress": true,
  "in_progress_batches": [
    { "batch_id": "BATCH-02LGEHRR1BZSPA6WRY1T3H4CD", "status": "closing" }
  ],
  "completed_batches": [
    { "batch_id": "BATCH-01KFDKXMQ637EKEAY410MSQSXB", "status": "settled" }
  ],
  "max_closed_at": "2026-03-24T22:00:00Z",
  "correlation_id": "b2c3d4e5-f6a7-8901-bcde-f12345678901"
}
```

Polling for settlement
Use `last_checked_at` with the `max_closed_at` value from the previous response to poll efficiently for newly completed batches without re-fetching old data.

## Next steps

* [Close a batch manually](/docs/how-tos/manage-transactions/close-batch-manually)
* [About batch settlement](/docs/concepts/transactions/batch-settlement)
* [Generate a transaction report](/docs/how-tos/reports/generate-transaction-report)