> This page is for version v2 (default).
> For other versions, use one of these documentation indexes:
> - v2 (default): https://developers.clearpay.co.uk/v-2/llms.txt
> - v1: https://developers.clearpay.co.uk/v-1/llms.txt

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

# Capture Payment

POST https://global-api-sandbox.afterpay.com/v2/payments/{orderId}/capture
Content-Type: application/json

This endpoint captures a full or partial payment. Any amounts successfully captured will be settled from Clearpay to the merchant's nominated bank account on the following day. Records of all payments captured against an order are returned in the events list as events of type, "CAPTURED".

This operation is [idempotent](/idempotent-requests) based on the `requestId` (if provided), which allows for the safe retry of requests, guaranteeing the payment operation is only performed once.

Authorisation expires after 13 days and then the transaction is automatically voided. Voided transactions are frozen and cannot be reopened or changed in any way. In this case your only option is to use the v2/checkouts endpoint to create a new order.

## Successful Response (201)

If successful, returns an updated copy of the [Payment object](/payment-object), with the newly captured payment appended to the `events` array as a [Payment Event object](/payment-event-object) with a `type` of "CAPTURED".

## Connection Timeouts

| Timeout | Time (Seconds) |
| :------ | :------------- |
| Open    | 10             |
| Read    | 70             |

## Errors

In addition to the [PUT/POST Errors](/put-post-errors) applicable to all POST endpoints, the following errors are specific to Capture Payment:

| HTTP Status Code              | errorCode          | Description                                                                                              |
| :---------------------------- | :----------------- | :------------------------------------------------------------------------------------------------------- |
| **404**  Not Found            | `not_found`        | No numeric `orderId` was provided, or an invalid string was provided.                                    |
| **410**  Gone                 | `payment_captured` | Payment has already been fully captured for this order, or partially captured with the remainder voided. |
| **412**  Precondition Failed  | `error`            | A numeric `orderId` was provided, but did not match any valid order.                                     |
| **412**  Precondition Failed  | `invalid_state`    | The order was declined by Clearpay; no payment can be captured for this order.                           |
| **412**  Precondition Failed  | `payment_voided`   | The auth for this order has already been completely voided.                                              |
| **412**  Precondition Failed  | `payment_expired`  | The auth for this order has expired; no further payment can be captured.                                 |
| **422**  Unprocessable Entity | `invalid_object`   | The `amount` was missing or invalid, or the `paymentEventMerchantReference` exceeded 128 characters.     |
| **422**  Unprocessable Entity | `invalid_amount`   | The `amount` was less than the minimum capture amount, or more than the `openToCaptureAmount`.           |

Reference: https://developers.clearpay.co.uk/deferred-payment-flow/capture-payment

## Authentication

- `Authorization` header (basic auth, required) — Basic authentication of the form `Basic <base64(username:password)>`.

## Request

### Path parameters

- `orderId` (string, required) — The unique ID of the Clearpay Order, returned as the `id` property of the [Auth](/deferred-payment-flow/auth) response.

### Headers

- `Accept` (string, optional, default: application/json)

### Body (application/json)

This endpoint expects an object.

- `amount` (V2PaymentsOrderIdCapturePostRequestBodyContentApplicationJsonSchemaAmount, required) — The capture amount. This must be between 1.00 and the `openToCaptureAmount` (inclusive).
- `requestId` (string, optional) — A unique request ID, required for safe retries. It is recommended that the merchant generate a UUID for each unique request.
- `merchantReference` (string, optional) — The merchant's order ID/reference. This will update any value previously provided in the [Create Checkout](/api-reference/online-api/checkouts/create-checkout) request.
- `paymentEventMerchantReference` (string, optional) — A unique reference for the individual payment capture event. If provided, the value will appear in the daily settlement file as "Payment Event ID". Limited to 128 characters.

## Types

### V2PaymentsOrderIdCapturePostRequestBodyContentApplicationJsonSchemaAmount

The capture amount. This must be between 1.00 and the `openToCaptureAmount` (inclusive).

- `amount` (string, required, default: 0.00) — The amount as a string representation of a decimal number, rounded to 2 decimal places.
- `currency` (string, required, default: GBP) — The currency in [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) format.

## Examples

**Request**

```json
{
  "amount": {
    "amount": "0.00",
    "currency": "GBP"
  }
}
```

**SDK Code**

```python
import requests

url = "https://global-api-sandbox.afterpay.com/v2/payments/orderId/capture"

payload = { "amount": {
        "amount": "0.00",
        "currency": "GBP"
    } }
headers = {
    "User-Agent": "User-Agent"
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers, auth=("<username>", "<password>"))

print(response.json())
```

```javascript
const url = 'https://global-api-sandbox.afterpay.com/v2/payments/orderId/capture';
const credentials = btoa("<username>:<password>");

const options = {
  method: 'POST',
  headers: {
    'User-Agent': 'User-Agent',
    Authorization: `Basic ${credentials}`,
    'Content-Type': 'application/json'
  },
  body: '{"amount":{"amount":"0.00","currency":"GBP"}}'
};

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"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://global-api-sandbox.afterpay.com/v2/payments/orderId/capture"

	payload := strings.NewReader("{\n  \"amount\": {\n    \"amount\": \"0.00\",\n    \"currency\": \"GBP\"\n  }\n}")

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

	req.Header.Add("User-Agent", "User-Agent")
	req.SetBasicAuth("<username>", "<password>")
	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
require 'uri'
require 'net/http'

url = URI("https://global-api-sandbox.afterpay.com/v2/payments/orderId/capture")

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

request = Net::HTTP::Post.new(url)
request["User-Agent"] = 'User-Agent'
request.basic_auth("<username>", "<password>")
request["Content-Type"] = 'application/json'
request.body = "{\n  \"amount\": {\n    \"amount\": \"0.00\",\n    \"currency\": \"GBP\"\n  }\n}"

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.post("https://global-api-sandbox.afterpay.com/v2/payments/orderId/capture")
  .header("User-Agent", "User-Agent")
  .basicAuth("<username>", "<password>")
  .header("Content-Type", "application/json")
  .body("{\n  \"amount\": {\n    \"amount\": \"0.00\",\n    \"currency\": \"GBP\"\n  }\n}")
  .asString();
```

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

$client = new \GuzzleHttp\Client();

$response = $client->request('POST', 'https://global-api-sandbox.afterpay.com/v2/payments/orderId/capture', [
  'body' => '{
  "amount": {
    "amount": "0.00",
    "currency": "GBP"
  }
}',
  'headers' => [
    'Content-Type' => 'application/json',
    'User-Agent' => 'User-Agent',
  ],
    'auth' => ['<username>', '<password>'],
]);

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

```csharp
using RestSharp;
using RestSharp.Authenticators;

var client = new RestClient("https://global-api-sandbox.afterpay.com/v2/payments/orderId/capture");
client.Authenticator = new HttpBasicAuthenticator("<username>", "<password>");
var request = new RestRequest(Method.POST);
request.AddHeader("User-Agent", "User-Agent");

request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{\n  \"amount\": {\n    \"amount\": \"0.00\",\n    \"currency\": \"GBP\"\n  }\n}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let credentials = Data("<username>:<password>".utf8).base64EncodedString()

let headers = [
  "User-Agent": "User-Agent",
  "Authorization": "Basic \(credentials)",
  "Content-Type": "application/json"
]
let parameters = ["amount": [
    "amount": "0.00",
    "currency": "GBP"
  ]] as [String : Any]

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

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