Available Products

The GET /payments/available-products endpoint returns a complete view of the payment rails enabled for a given identity, grouped by currency. Use it to dynamically build payment flows without hardcoding supported methods.

Direction: Both (Pay-in & Pay-out)

Query parameters

Parameter	Type	Required	Description
`identityId`	`string`	No	Filter results by identity
`currencies`	`string`	No	Comma-separated currency codes to filter (e.g., `ARS,CLP`)

Response structure

Field	Type	Description
`supportedPaymentCurrencies`	`string[]`	Currencies with available pay-in products
`supportedPayoutCurrencies`	`string[]`	Currencies with available pay-out products
`supportedPaymentMethods`	`string[]`	All pay-in node types across all currencies
`supportedWithdrawalMethods`	`string[]`	All pay-out node types across all currencies
`byCurrency`	`array`	Per-currency breakdown (see below)

byCurrency object

Field	Type	Description
`currency`	`string`	`ISO 4217` currency code
`payin.paymentMethods`	`string[]`	Pay-in node types for this currency
`payin.products`	`payment-node-get[]`	Full product details for each pay-in method
`payout.withdrawalMethods`	`string[]`	Pay-out node types for this currency
`payout.products`	`payment-node-get[]`	Full product details for each pay-out method

Each product in payin.products and payout.products follows the payment-node-get schema and includes requiredFields, nodeSchema, requiredFieldTypes, minAmount, maxAmount, and validOrigins/validDestinations.

Example

Request

GET /sandbox/payments/available-products?identityId=679c482ee4420cb5b0966c9a&currencies=ARS,CLP 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

const response = await fetch('https://api.conomyhq.com/sandbox/payments/available-products?identityId=679c482ee4420cb5b0966c9a&currencies=ARS,CLP', {
  method: 'GET',
  headers: {
    'x-api-key': '{YOUR_API_KEY}',
    'Authorization': 'Bearer {ACCESS_TOKEN}',
    'conomyhq-api-version': '24-04-2025',
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
  },
});

const data = await response.json();

import requests

response = requests.get(
    'https://api.conomyhq.com/sandbox/payments/available-products?identityId=679c482ee4420cb5b0966c9a&currencies=ARS,CLP',
    headers={
    'x-api-key': '{YOUR_API_KEY}',
    'Authorization': 'Bearer {ACCESS_TOKEN}',
    'conomyhq-api-version': '24-04-2025',
    'User-Agent': 'MyApp/1.0',
    'Accept': 'application/json',
    },
)

data = response.json()

package main

import (
	"net/http"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.conomyhq.com/sandbox/payments/available-products?identityId=679c482ee4420cb5b0966c9a&currencies=ARS,CLP", 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/available-products?identityId=679c482ee4420cb5b0966c9a&currencies=ARS,CLP")
        .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

{
  "supportedPaymentCurrencies": [
    "ARS",
    "CLP"
  ],
  "supportedPayoutCurrencies": [
    "ARS",
    "CLP"
  ],
  "supportedPaymentMethods": [
    "CVU",
    "ETPAY",
    "PCT",
    "PIX"
  ],
  "supportedWithdrawalMethods": [
    "BANK_ACCOUNT"
  ],
  "byCurrency": [
    {
      "currency": "ARS",
      "payin": {
        "paymentMethods": [
          "CVU",
          "PCT"
        ],
        "products": [
          {
            "name": "PCT",
            "type": "PCT",
            "currency": "ARS",
            "product": "ARS:ARS",
            "requiredFields": [
              "pct.customer.phoneNumber",
              "pct.customer.phoneNumberPrefix",
              "pct.customer.email"
            ],
            "validDestinations": [
              "ACCOUNT"
            ]
          }
        ]
      },
      "payout": {
        "withdrawalMethods": [
          "BANK_ACCOUNT"
        ],
        "products": [
          {
            "name": "BANK_ACCOUNT",
            "type": "BANK_ACCOUNT",
            "currency": "ARS",
            "product": "ARS:ARS",
            "requiredFields": [
              "bank.accountNumber",
              "bank.bank"
            ],
            "validOrigins": [
              "ACCOUNT"
            ]
          }
        ]
      }
    }
  ]
}

Notes

Cross-currency products appear under the settlement currency (e.g., a PIX pay-in that settles in CLP will appear under byCurrency[CLP].payin).
Use nodeSchema to dynamically render input forms for each payment method.
Use requiredFields with requiredFieldTypes to validate user input before submitting a payment.