Simulate a payment

In sandbox, payment providers never transfer real funds, so a payment created and captured stays in CAPTURED indefinitely. Use POST /simulate/payment to fire a synthetic provider webhook that advances the transaction to RECEIVED and then SETTLED — the same path a real payment takes.

Attention

This endpoint is only available in sandbox. Calling it in production returns 403.

Flow

Create payment

Create and capture the payment as usual.

Simulate receipt

Call POST /simulate/payment with the payment ID.

Wait for SETTLED

The transaction advances within a few seconds.

Handle webhook

Your webhook endpoint receives the final state event.

Create and capture the payment

Follow the standard Create a payment flow. Once the payment reaches CREATED or AUTHORIZED, proceed to the simulation step.

Simulate the fund receipt

Request

POST /sandbox/simulate/payment 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

{
  "transactionId": "<PAYMENT_ID>",
  "amount": "10000"
}

const response = await fetch('https://api.conomyhq.com/sandbox/simulate/payment', {
  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({
    "transactionId": "<PAYMENT_ID>",
    "amount": "10000"
  }),
});

const data = await response.json();

import requests

payload = {
  "transactionId": "<PAYMENT_ID>",
  "amount": "10000"
}

response = requests.post(
    'https://api.conomyhq.com/sandbox/simulate/payment',
    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(`{
  "transactionId": "<PAYMENT_ID>",
  "amount": "10000"
}`)
	body := bytes.NewReader(payload)
	req, _ := http.NewRequest("POST", "https://api.conomyhq.com/sandbox/simulate/payment", 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!({
  "transactionId": "<PAYMENT_ID>",
  "amount": "10000"
});

    let response = client
        .post("https://api.conomyhq.com/sandbox/simulate/payment")
        .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

{
  "ok": true,
  "transactionId": "<PAYMENT_ID>",
  "simulatedAmount": "10000",
  "currency": "ARS",
  "message": "Payment simulated successfully. The transaction should advance to SETTLED within a few seconds.",
  "reference": "sandbox-sim-1716220800000-x7k3m2"
}

Note

amount is optional. Omitting it defaults to "5000". The value does not need to match the original payment amount — it represents the amount the simulated provider reports as received.

Verify the final state

Poll the payment until the status reaches SETTLED, or wait for the webhook event your endpoint is subscribed to.

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>",
  "status": "SETTLED",
  "settledAt": "2026-05-18T10:02:11Z"
}

Error states

Status	Cause	Fix
`400`	`transactionId` missing or body invalid	Include `transactionId` in the request body.
`403`	Called in production	Only available in sandbox.
`422`	Payment not in `CREATED` or `AUTHORIZED`	Verify the payment status before simulating.