Capture and reconcile

Creating a payment only records the instruction. Capture tells Conomy to commit the movement and start provider processing. Reconciliation is the step where your system mirrors the final state from webhooks or reads.

Attention

Do not treat CAPTURED as final success. It means the movement was committed. Use terminal states such as SETTLED, FAILED, EXPIRED, UNSETTLED, or refund events to close your business workflow.

Flow

Create payment

Receive the payment ID.

Authorize if needed

Some rails reserve funds before capture.

Capture

Commit the movement.

Read state

Fetch payment state when the user returns.

Mirror final event

Use webhooks as the durable source of truth.

Capture the payment

Request

POST /sandbox/payments/{PAYMENT_ID}/captured HTTP/1.1
Host: api.conomyhq.com
x-api-key: {YOUR_API_KEY}
Authorization: Bearer {ACCESS_TOKEN}
conomyhq-api-version: 24-04-2025
User-Agent: MyApp/1.0
Content-Type: application/json
Accept: application/json

{}

const response = await fetch('https://api.conomyhq.com/sandbox/payments/{PAYMENT_ID}/captured', {
  method: 'POST',
  headers: {
    'x-api-key': '{YOUR_API_KEY}',
    'Authorization': 'Bearer {ACCESS_TOKEN}',
    'conomyhq-api-version': '24-04-2025',
    'User-Agent': 'MyApp/1.0',
    'Content-Type': 'application/json',
    'Accept': 'application/json',
  },
  body: JSON.stringify({}),
});

const data = await response.json();

import requests

payload = {}

response = requests.post(
    'https://api.conomyhq.com/sandbox/payments/{PAYMENT_ID}/captured',
    headers={
    'x-api-key': '{YOUR_API_KEY}',
    'Authorization': 'Bearer {ACCESS_TOKEN}',
    'conomyhq-api-version': '24-04-2025',
    'User-Agent': 'MyApp/1.0',
    'Content-Type': 'application/json',
    'Accept': 'application/json',
    },
    json=payload,
)

data = response.json()

package main

import (
	"bytes"
	"net/http"
)

func main() {
	payload := []byte(`{}`)
	body := bytes.NewReader(payload)
	req, _ := http.NewRequest("POST", "https://api.conomyhq.com/sandbox/payments/{PAYMENT_ID}/captured", body)
	req.Header.Set("x-api-key", "{YOUR_API_KEY}")
	req.Header.Set("Authorization", "Bearer {ACCESS_TOKEN}")
	req.Header.Set("conomyhq-api-version", "24-04-2025")
	req.Header.Set("User-Agent", "MyApp/1.0")
	req.Header.Set("Content-Type", "application/json")
	req.Header.Set("Accept", "application/json")

	client := &http.Client{}
	resp, _ := client.Do(req)
	defer resp.Body.Close()
}

use reqwest::Client;
use serde_json::json;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let payload = json!({});

    let response = client
        .post("https://api.conomyhq.com/sandbox/payments/{PAYMENT_ID}/captured")
        .header("x-api-key", "{YOUR_API_KEY}")
        .header("Authorization", "Bearer {ACCESS_TOKEN}")
        .header("conomyhq-api-version", "24-04-2025")
        .header("User-Agent", "MyApp/1.0")
        .header("Content-Type", "application/json")
        .header("Accept", "application/json")
        .json(&payload)
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    Ok(())
}

Response

{
  "id": "<PAYMENT_ID>",
  "status": "CAPTURED",
  "capturedAt": "2026-05-18T10:00:00Z"
}

Read the payment

Use this when the customer returns to your product or an operator opens a transaction detail page.

Request

GET /sandbox/payments/{PAYMENT_ID} HTTP/1.1
Host: api.conomyhq.com
x-api-key: {YOUR_API_KEY}
Authorization: Bearer {ACCESS_TOKEN}
conomyhq-api-version: 24-04-2025
User-Agent: MyApp/1.0
Accept: application/json

package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.conomyhq.com/sandbox/payments/{PAYMENT_ID}", nil)
	req.Header.Set("x-api-key", "{YOUR_API_KEY}")
	req.Header.Set("Authorization", "Bearer {ACCESS_TOKEN}")
	req.Header.Set("conomyhq-api-version", "24-04-2025")
	req.Header.Set("User-Agent", "MyApp/1.0")
	req.Header.Set("Accept", "application/json")

	client := &http.Client{}
	resp, _ := client.Do(req)
	defer resp.Body.Close()
}

use reqwest::Client;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = Client::new();
    let response = client
        .get("https://api.conomyhq.com/sandbox/payments/{PAYMENT_ID}")
        .header("x-api-key", "{YOUR_API_KEY}")
        .header("Authorization", "Bearer {ACCESS_TOKEN}")
        .header("conomyhq-api-version", "24-04-2025")
        .header("User-Agent", "MyApp/1.0")
        .header("Accept", "application/json")
        .send()
        .await?;

    let data: serde_json::Value = response.json().await?;
    Ok(())
}

Response

{
  "id": "<PAYMENT_ID>",
  "externalId": "order-1001",
  "type": "PURCHASE",
  "status": "SETTLED",
  "product": "CLP:CLP",
  "purchaseAmount": "49990",
  "purchaseCurrency": "CLP",
  "currency": "CLP",
  "capturedAt": "2026-05-18T10:00:00Z",
  "settledAt": "2026-05-18T10:02:11Z"
}

Store final state idempotently

Use payment.id as your transaction key and store the latest known state. If the same webhook arrives twice, update the same row and return 2xx.