# Authorize and capture transactions

> Learn how to authorize and capture payments for settlement using the API

<AudienceInfo audiences={['developers']} />

For some businesses, it makes sense to authorize a transaction first and then capture later. When you authorize, you verify that the customer has sufficient funds, and you place a hold on that amount without actually processing the transaction and taking the money. Authorizing a transaction gives merchants time to verify inventory, prepare shipments, or complete services before finalizing the charge. Capturing the transaction is what puts the transaction in a batch for settlement and starts the process of moving the funds from the customer to the merchant account.

Capturing an authorized transaction later also allows merchants to capture part of the authorized amount if the final total ends up being less than expected, avoiding the need for refunds.

This guide covers how to authorize and capture transactions through the API. To authorize and capture a payment in one step, use the [Make a transaction](/guides/pay-in-developer-transactions-create) endpoint instead.

## Considerations

Keep these considerations in mind when working with transactions:

* Authorizing a transaction reserves funds for the merchant but doesn't move them.
* You must capture an authorized transaction to complete it and move the funds.
* You can capture an amount equal to or less than the original authorization, but not less than 85% of the original authorized amount.
* If you need to capture less than 85% of the authorized amount or more than the authorized amount, then void the authorization and create a new sale transaction.
* Service fees can be adjusted proportionally when capturing partial amounts, and can vary based on your service fee configuration. See [Pass-through fees](/guides/pay-in-fees-passthrough-overview) for more information.
* Authorized transactions aren't flagged for settlement until they're captured.
* If an authorized transaction isn't captured within 10 days, Payabli voids the transaction. If you try to capture the voided transaction, the capture will fail.

<Warning>
  If aren't using a stored payment method provided by an embedded component to run transactions, you must secure cardholder, bank account data, and customer IP address because your PCI scope is expanded.
</Warning>

## Authorize a transaction

Send a POST request to the Pay In authorize endpoint (either v1 or v2) to authorize a payment transaction. This action reserves funds and returns an authorization code. See the [API references](/guides/pay-in-developer-transactions-auth-capture#related-resources) for this endpoint for full documentation.

<Tip>
  See [Pay In transaction APIs v2](/developers/api-reference/moneyIn/v2) for more information about v1 versus v2 of the transaction APIs.
</Tip>

This example authorizes a card transaction for \$100, with no service fee, for entrypoint `f743aed24a`. The customer ID is `4440`.

<Tabs>
  <Tab title="v1 API request">
    <EndpointRequestSnippet endpoint="POST /api/MoneyIn/authorize" example="AuthorizeTransaction" />
  </Tab>

  <Tab title="v2 API request">
    <EndpointRequestSnippet endpoint="POST /v2/MoneyIn/authorize" example="CardAuthorization" />
  </Tab>
</Tabs>

A successful request returns a 200 response with a JSON body containing a referenceId which you'll need for the capture operation.

<Tabs>
  <Tab title="v1 API response">
    <EndpointResponseSnippet endpoint="POST /api/MoneyIn/authorize" example="AuthorizeTransaction" />
  </Tab>

  <Tab title="v2 API response">
    <EndpointResponseSnippet endpoint="POST /v2/MoneyIn/authorize" example="CardAuthorization" />
  </Tab>
</Tabs>

<Check>
  After authorizing a transaction, you can capture the transaction to complete it and move the funds from the customer to the merchant account.
</Check>

## Capture a transaction

To capture an authorized transaction and start the settlement process, send a POST request to `/MoneyIn/capture/{transId}`. This endpoint allows you to capture the full authorized amount or a partial amount (minimum 85% of the original authorization) with flexible service fee adjustments. See the [API reference](/developers/api-reference/moneyin/capture-an-authorized-transaction) for full documentation.

When capturing a transaction, the following rules apply:

* **Full capture**: Capture the exact authorized amount with the original or adjusted service fee
* **Partial capture**: Capture less than the authorized amount (minimum 85% of original total)
* **Service fee adjustment**: Adjust the service fee proportionally or as needed when capturing partial amounts
* **Out-of-range captures**: If you need to capture less than 85% or more than the authorized amount, you must void the original authorization and create a new sale transaction with the correct amount.

Each example captures a \$100 card transaction for the transaction 10-7d9cd67d-2d5d-4cd7-a1b7-72b8b201ec13.

<AccordionGroup>
  <Accordion title="V1 API examples">
    <Tabs>
      <Tab title="Full capture with fee example">
        This example captures the full authorized amount of \$100.00 with a service fee of \$5.00.

        <EndpointRequestSnippet endpoint="POST MoneyIn/capture/{transId}" example="CaptureFullAmountwithFee" />
      </Tab>

      <Tab title="Partial capture with fee example">
        This example captures \$85.00 of the authorized amount, plus a reduced service fee of \$4.00. The remaining \$15 is released back to the customer.

        <EndpointRequestSnippet endpoint="POST MoneyIn/capture/{transId}" example="CapturePartialAmountwithFee" />
      </Tab>

      <Tab title="Full capture without fee example">
        This example captures \$100.00 of the authorized amount with no service fee.

        <EndpointRequestSnippet endpoint="POST MoneyIn/capture/{transId}" example="CaptureNoFee" />
      </Tab>
    </Tabs>
  </Accordion>

  <Accordion title="V2 API examples">
    <Tabs>
      <Tab title="Full capture with fee example">
        This example captures the full authorized amount of \$100.00 with a service fee of \$5.00.

        <EndpointRequestSnippet endpoint="POST /v2/MoneyIn/capture/{transId}" example="FullCapture" />
      </Tab>

      <Tab title="Partial capture with fee example">
        This example captures \$85.00 of the authorized amount, plus a reduced service fee of \$4.00. The remaining \$15 is released back to the customer.

        <EndpointRequestSnippet endpoint="POST /v2/MoneyIn/capture/{transId}" example="PartialCapture" />
      </Tab>
    </Tabs>
  </Accordion>
</AccordionGroup>

A successful capture request returns a 200 response with a JSON body containing the transaction details.

<Tabs>
  <Tab title="v1 API response">
    <EndpointResponseSnippet endpoint="POST /api/MoneyIn/capture/{transId}" example="FullCapture" />
  </Tab>

  <Tab title="v2 API response">
    <EndpointResponseSnippet endpoint="POST /v2/MoneyIn/capture/{transId}" example="FullCapture" />
  </Tab>
</Tabs>

## Real-world example

This example illustrates a homeowner reserving a clubhouse for an event with a \$200 deposit for cleaning and damages, plus a 3% service fee. After the event, the clubhouse admin calculates the actual charges and charges the homeowner for the final amount.

**Initial authorization**: \$200.00 + \$6.00 (3% fee) = \$206.00 total

<AccordionGroup>
  <Accordion title="Scenario 1: Partial capture within threshold">
    In this case, the homeowner left the clubhouse in good condition, resulting in lower cleaning fees. The final charges are within the 85% threshold of the original authorization.

    Final charges: \$180.00 + \$5.40 (3% fee) = \$185.40

    Because \$185.40 is greater than 85% of \$206.00 (\$175.10), you can use the capture endpoint:

    ```json
      POST /api/MoneyIn/capture/{transId}
      {
        "paymentDetails": {
          "totalAmount": 185.40,
          "serviceFee": 5.40
        }
      }
    ```
  </Accordion>

  <Accordion title="Scenario 2: Amount below threshold">
    In this case, the homeowner left the clubhouse in excellent condition. Their cleaning fee was significantly reduced, leading to final charges below the 85% threshold of the original authorization.
    Final charges: \$60.00 + \$1.80 (3% fee) = \$61.80

    Because \$61.80 is less than 85% of \$206.00 (\$175.10), you must:

    1. Void the original \$206.00 authorization
    2. Create a new sale transaction for \$61.80
  </Accordion>

  <Accordion title="Scenario 3: Amount exceeds authorization">
    In this case the homeowner incurred additional costs for damages, leading to final charges exceeding the initial authorization.

    Final charges: \$300.00 + \$9.00 (3% fee) = \$309.00

    Because this exceeds the original authorization, you must:

    1. Void the original \$206.00 authorization
    2. Create a new sale transaction for \$309.00
  </Accordion>
</AccordionGroup>

## Migrating from GET to POST endpoint

<Warning>
  **Important API update**: The GET capture endpoint was sunset on November 24, 2025. All integrations should use the POST capture endpoint, which supports both full and partial captures with flexible service fee adjustments. The GET endpoint currently supports only captures for the exact authorized amount.
</Warning>

If you're currently using the GET endpoint (`GET /MoneyIn/capture/{transId}/{amount}`), you need to migrate to the POST endpoint.

Here are the key differences between the two endpoints:

| Feature                | GET Endpoint (Deprecated) | POST Endpoint            |
| ---------------------- | ------------------------- | ------------------------ |
| Partial capture        | Not supported             | Supported (≥85% of auth) |
| Service fee adjustment | Not supported             | Supported                |
| Request format         | URL parameters            | JSON body                |
| Use cases              | Exact amount only         | All capture scenarios    |

And here are examples for both endpoints:

**Before (GET endpoint):**

<EndpointRequestSnippet endpoint="GET MoneyIn/capture/{transId}/{amount}" example="FullCapture" />

**After (POST endpoint):**

<EndpointRequestSnippet endpoint="POST MoneyIn/capture/{transId}" example="CaptureFullAmountwithFee" />

## Related resources

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

<AccordionGroup>
  <Accordion title="References">
    * **[Pay In schemas](/guides/pay-in-schemas-overview)** - Learn about Pay In (money in) transaction schemas
    * **[Pay In statuses](/guides/pay-in-status-reference)** - Learn about Pay In (money in) statuses
  </Accordion>

  <Accordion title="Related topics">
    * **[Make a sale transaction](/guides/pay-in-developer-transactions-create)** - Learn how to authorize and capture a sales transaction in one step using the API
    * **[Authorize API (v2)](/developers/api-reference/moneyinV2/authorize-a-transaction)** - Learn about the Authorize API (v2) for authorizing transactions
    * **[Capture API (v2)](/developers/api-reference/moneyinV2/capture-an-authorized-transaction)** - Learn about the Capture API (v2) for capturing authorized transactions
  </Accordion>
</AccordionGroup>