WalletConnect Pay

https://docs.walletconnect.com
Admin
WalletConnect Pay is a complete crypto payment solution enabling merchants and PSPs to accept...
Tokens:455,511
Snippets:3,056
Trust Score:9.5
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### List payments with Go

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments

Go example using net/http. Sends a GET request with the API key header and prints the response body.

```go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.pay.walletconnect.com/v1/payments"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Api-Key", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

--------------------------------

### Install Reown.WalletKit NuGet package

Source: https://docs.walletconnect.com/wallets/c-sharp/installation

Use this command to install the Reown.WalletKit NuGet package for the Wallet SDK in a .NET project.

```bash
dotnet add package Reown.WalletKit

```

--------------------------------

### Complete WalletConnect Pay ViewModel Example

Source: https://docs.walletconnect.com/payments/wallets/standalone/kotlin

Complete ViewModel implementation for WalletConnect Pay. Initializes the SDK with a WCP ID and package name, then processes a payment link by fetching options, optionally collecting data via WebView, getting required actions, signing them, and confirming the payment. Handles payment statuses including SUCCEEDED, PROCESSING, FAILED, EXPIRED, REQUIRES_ACTION, and CANCELLED.

```kotlin
import com.walletconnect.pay.Pay
import com.walletconnect.pay.WalletConnectPay
import kotlinx.coroutines.launch

class PaymentViewModel : ViewModel() {

        fun initializeSdk() {
            WalletConnectPay.initialize(
                Pay.SdkConfig(
                    appId = "your-wcp-id",            // Your WCP ID
                    packageName = "com.your.app"
                )
            )
        }

    fun processPayment(paymentLink: String, walletAddress: String) {
        viewModelScope.launch {
            // Step 1: Get payment options
            val optionsResult = WalletConnectPay.getPaymentOptions(
                paymentLink = paymentLink,
                accounts = listOf(
                    "eip155:1:$walletAddress",
                    "eip155:8453:$walletAddress",
                    "eip155:10:$walletAddress"
                )
            )

            optionsResult.onSuccess { response ->
                val paymentId = response.paymentId
                val selectedOption = response.options.first()

                // Step 2: Collect data if required for selected option (via WebView).
                // IC must happen BEFORE fetching the required actions — the WebView
                // submits the data directly to the backend.
                selectedOption.collectData?.url?.let { webViewUrl ->
                    // Show WebView and wait for IC_COMPLETE
                    showDataCollectionWebView(webViewUrl)
                    return@launch // Resume after WebView completes
                }

                // Step 3: Get required actions
                val actionsResult = WalletConnectPay.getRequiredPaymentActions(
                    paymentId = paymentId,
                    optionId = selectedOption.id
                )

                actionsResult.onSuccess { actions ->
                    // Step 4: Sign actions
                    val data = signActions(actions)

                    // Step 5: Confirm payment
                    val confirmResult = WalletConnectPay.confirmPayment(
                        paymentId = paymentId,
                        optionId = selectedOption.id,
                        data = data
                    )

                    confirmResult.onSuccess { confirmation ->
                        handlePaymentStatus(confirmation.status)
                    }.onFailure { error ->
                        handleError(error)
                    }
                }.onFailure { error ->
                    handleError(error)
                }
            }.onFailure { error ->
                handleError(error)
            }
        }
    }

    private suspend fun signActions(actions: List<Pay.RequiredAction>): List<String> {
        return actions.map { action ->
            when (action) {
                is Pay.RequiredAction.WalletRpc -> {
                    // Implement signing logic using your wallet
                    signWithWallet(action.action)
                }
            }
        }
    }

    private fun handlePaymentStatus(status: Pay.PaymentStatus) {
        when (status) {
            Pay.PaymentStatus.SUCCEEDED -> showSuccess()
            Pay.PaymentStatus.PROCESSING -> showProcessing()
            Pay.PaymentStatus.FAILED -> showFailure()
            Pay.PaymentStatus.EXPIRED -> showExpired()
            Pay.PaymentStatus.REQUIRES_ACTION -> { /* Handle additional actions */ }
            Pay.PaymentStatus.CANCELLED -> showCancelled()
        }
    }
}

```

--------------------------------

### Install with npm

Source: https://docs.walletconnect.com/payments/wallets/standalone/web

Install the WalletConnect Pay SDK using npm. Requires Node.js 16+ and @walletconnect/pay 1.1.0 or later.

```bash
npm install @walletconnect/pay

```

--------------------------------

### Install with yarn

Source: https://docs.walletconnect.com/payments/wallets/standalone/web

Install the WalletConnect Pay SDK using yarn. Requires Node.js 16+ and @walletconnect/pay 1.1.0 or later.

```bash
yarn add @walletconnect/pay

```

--------------------------------

### WalletConnect Pay CLI Examples

Source: https://docs.walletconnect.com/agents/overview

Example commands for checking payment status, creating a payment, and completing a payment using the staging API.

```bash
# Check a payment's status
walletconnect-pay status pay_abc123 --staging

# Create a $10 payment (1000 = minor units / cents)
walletconnect-pay create 1000 --staging

# Complete a payment with a connected wallet
walletconnect-pay checkout pay_abc123 --staging
```

--------------------------------

### Install Expo Application Package

Source: https://docs.walletconnect.com/wallets/react-native/installation

Additional setup for Expo projects to install the expo-application package.

```bash
npx expo install expo-application

```

--------------------------------

### Example response for get merchant payments

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-merchants-merchant-id-payments

Example 200 response showing the structure of payment data and statistics returned by the endpoint.

```json
{
  "data": [
    {
      "payment_id": "<string>",
      "merchant_id": "<string>",
      "reference_id": "<string>",
      "status": "requires_action",
      "is_terminal": true,
      "wallet_name": "<string>",
      "token_symbol": "<string>",
      "token_decimals": 0,
      "token_logo": "<string>",
      "chain_logo": "<string>",
      "wallet_logo": "<string>",
      "chain_id": "<string>",
      "buyer_caip10": "<string>",
      "token_caip19": "<string>",
      "tx_hash": "<string>",
      "nonce": 1073741823,
      "token_amount": "<string>",
      "fiat_amount": -1,
      "fiat_currency": "<string>",
      "created_at": "<string>",
      "last_updated_at": "<string>",
      "settled_at": "<string>",
      "settlement_status": "<string>",
      "settlement_tx_hash": "<string>"
    }
  ],
  "stats": {
    "total_customers": 1073741823,
    "total_revenue": {
      "amount": 123,
      "currency": "<string>"
    },
    "total_transactions": 1073741823
  },
  "next_cursor": "<string>"
}
```

--------------------------------

### CLI usage examples

Source: https://docs.walletconnect.com/agents/overview

Examples of common walletconnect-staking commands for staking, checking status, balance, claiming rewards, and unstaking.

```bash
# Stake 1000 WCT for 52 weeks
walletconnect-staking stake 1000 52

# Check staking position and rewards (read-only, no wallet needed)
walletconnect-staking status --address=0x...

# Check WCT balance
walletconnect-staking balance --address=0x...

# Claim staking rewards (requires wallet)
walletconnect-staking claim

# Withdraw all staked WCT (after lock expires)
walletconnect-staking unstake
```

--------------------------------

### Initialize WalletKitClient with Core and Metadata

Source: https://docs.walletconnect.com/wallets/c-sharp/usage

Initializes the WalletKitClient by first creating a Core instance with ProjectId and Name, then defining a Metadata object, and finally calling WalletKitClient.Init with the core, metadata, and metadata.Name.

```csharp
var options = new CoreOptions()
{
    ProjectId = "...",
    Name = "my-app",
}

var core = new CoreClient(options);

```

```csharp
var metadata = new Metadata()
{
    Description = "An example wallet to showcase Wallet SDK",
    Icons = new[] { "https://walletconnect.com/meta/favicon.ico" },
    Name = $"wallet-csharp-test",
    Url = "https://walletconnect.com",
};

```

```csharp
var sdk = await WalletKitClient.Init(core, metadata, metadata.Name);

```

--------------------------------

### 200 response example

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-gateway-payment-id

Example response body for a successful GET request (HTTP 200). Contains payment amount details, buyer and merchant information, expiration timestamp, and status.

```json
{
  "amount": {
    "display": {
      "assetName": "USD Coin",
      "assetSymbol": "USDC",
      "decimals": 6,
      "iconUrl": "https://assets.walletconnect.com/usdc.png",
      "networkIconUrl": "https://assets.walletconnect.com/base.png",
      "networkName": "Base"
    },
    "unit": "caip19/eip155:8453/erc20:0x0000000000000000000000000000000000000000",
    "value": "1000000"
  },
  "buyer": {
    "accountCaip10": "eip155:1:0x0000000000000000000000000000000000000000",
    "accountProviderIcon": "https://example.com/icon.png",
    "accountProviderName": "Wallet"
  },
  "expiresAt": 1700000000,
  "merchant": {
    "iconUrl": "https://example.com/icon.png",
    "name": "Merchant"
  },
  "status": "requires_action"
}
```

--------------------------------

### Ethers: Get token balance with useAppKitProvider

Source: https://docs.walletconnect.com/apps/react/installation

Use this Ethers example to get a user's ERC-20 token balance. It uses useAppKitProvider and useAppKitAccount from @reown/appkit/react. The code creates a BrowserProvider, gets a signer, and calls balanceOf on the contract. It throws an error if the user is disconnected.

```typescript
import { useAppKitProvider, useAppKitAccount } from "@reown/appkit/react";
import { BrowserProvider, Contract, formatUnits } from "ethers";

const USDTAddress = "0x617f3112bf5397D0467D315cC709EF968D9ba546";

// The ERC-20 Contract ABI, which is a common contract interface
// for tokens (this is the Human-Readable ABI format)
const USDTAbi = [
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function balanceOf(address) view returns (uint)",
  "function transfer(address to, uint amount)",
  "event Transfer(address indexed from, address indexed to, uint amount)",
];

function Components() {
  const { address, isConnected } = useAppKitAccount();
  const { walletProvider } = useAppKitProvider("eip155");

  async function getBalance() {
    if (!isConnected) throw Error("User disconnected");

    const ethersProvider = new BrowserProvider(walletProvider);
    const signer = await ethersProvider.getSigner();
    // The Contract object
    const USDTContract = new Contract(USDTAddress, USDTAbi, signer);
    const USDTBalance = await USDTContract.balanceOf(address);

    console.log(formatUnits(USDTBalance, 18));
  }

  return <button onClick={getBalance}>Get User Balance</button>;
}
```

--------------------------------

### Install WalletConnect App SDK with Bun

Source: https://docs.walletconnect.com/apps/javascript/installation

Install the required packages using Bun: @reown/appkit, @reown/appkit-universal-connector, @reown/appkit-common, and ethers.

```bash
bun add @reown/appkit @reown/appkit-universal-connector @reown/appkit-common ethers

```

--------------------------------

### 200 response example for Get payment details

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments-id

Example 200 response body for a successful payment details request. Shows the payment status, reference ID, and option amount details including asset and network information.

```json
{
  "info": {
    "optionAmount": {
      "display": {
        "assetName": "USD Coin",
        "assetSymbol": "USDC",
        "decimals": 6,
        "iconUrl": "https://assets.walletconnect.com/usdc.png",
        "networkIconUrl": "https://assets.walletconnect.com/base.png",
        "networkName": "Base"
      },
      "unit": "caip19/eip155:8453/erc20:0x0000000000000000000000000000000000000000",
      "value": "1000000"
    },
    "txId": "0xabc123..."
  },
  "referenceId": "ORDER-123",
  "settlement": null,
  "status": "succeeded"
}
```

--------------------------------

### Use getUniversalConnector in main.js

Source: https://docs.walletconnect.com/apps/javascript/installation

Example usage in main.js: imports getUniversalConnector from './config/appKit.js', calls it in an async setup function, and checks if a session is already connected via universalConnector.provider.session. Assumes the connector was configured as shown in the TON or Tron examples.

```javascript
import { getUniversalConnector } from './config/appKit.js'

async function setup() {
  const universalConnector = await getUniversalConnector()

  // check if session is already connected
  if (universalConnector?.provider.session) {
    session = universalConnector?.provider.session
  }
}

setup() 

```

--------------------------------

### Install WalletConnect App SDK with npm

Source: https://docs.walletconnect.com/apps/javascript/installation

Install the required packages using npm: @reown/appkit, @reown/appkit-universal-connector, @reown/appkit-common, and ethers.

```bash
npm install @reown/appkit @reown/appkit-universal-connector @reown/appkit-common ethers

```

--------------------------------

### init()

Source: https://docs.walletconnect.com/payments/wallets/standalone/flutter

Initializes the WalletConnect Pay SDK.

```APIDOC
## Future<bool> init()

### Description
Initializes the SDK. Returns `true` on success or throws `PayInitializeError` on error.

### Method
`Future<bool> init()`

### Returns
- **Future<bool>** - `true` on success, otherwise throws `PayInitializeError`.
```

--------------------------------

### Example response for get merchant

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-merchants-merchantid

Shows the JSON structure returned by the API, including merchant details and settlement information.

```json
{
  "merchant": {
    "id": "mrch_7kBz2qR9xPvLmN4Yw",
    "name": "Acme Store",
    "email": "billing@acme.store",
    "status": "active",
    "iconUrl": "https://imagedelivery.net/example/acme-icon.png",
    "createdAt": "2025-06-15T10:30:00.000Z",
    "settlements": {
      "crypto": [
        {
          "id": "crypto_Xk7nWp8XmQj2YrTv6",
          "asset": "eip155:8453/erc20:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
          "destination": "eip155:8453:0x1234567890abcdef1234567890abcdef12345678"
        }
      ],
      "fiat": [
        {
          "id": "fiat_Bk4nWp8XmQj2YrTv6",
          "status": "active",
          "bankType": "ACH"
        }
      ]
    }
  }
}
```

--------------------------------

### Add reown_walletkit dependency to pubspec.yaml

Source: https://docs.walletconnect.com/payments/wallets/walletkit/flutter

Add the reown_walletkit package version ^1.5.1 to your pubspec.yaml dependencies. Then run 'flutter pub get' to install it.

```yaml
dependencies:
  reown_walletkit: ^1.5.1

```

--------------------------------

### Migrate package using .NET CLI

Source: https://docs.walletconnect.com/wallets/more/web3wallet-migration/unity

Use the .NET CLI to remove the old WalletConnect.Web3Wallet package and add the new Reown.WalletKit package.

```bash
# Remove the old package
dotnet remove package WalletConnect.Web3Wallet

# Add the new package
dotnet add package Reown.WalletKit
```

--------------------------------

### Install WalletKit and Core via npm

Source: https://docs.walletconnect.com/payments/wallets/walletkit/web

Install the required packages using npm. WalletConnect Pay is automatically included as part of WalletKit.

```bash
npm install @reown/walletkit @walletconnect/core

```

--------------------------------

### List payments with Java Unirest

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments

Java example using Unirest. Sends a GET request with the API key header and returns the response as a string.

```java
HttpResponse<String> response = Unirest.get("https://api.pay.walletconnect.com/v1/payments")
  .header("Api-Key", "<api-key>")
  .asString();
```

--------------------------------

### CLI usage examples

Source: https://docs.walletconnect.com/agents/overview

Common CLI commands for connecting a wallet, signing messages, checking the session, sending a transaction on Optimism, and disconnecting.

```bash
# Connect a wallet (shows QR code in terminal)
walletconnect connect

# Connect using a browser-based QR code
walletconnect connect --browser

# Sign a message
walletconnect sign "Hello from the terminal"

# Check connected wallet
walletconnect whoami

# Send a transaction on Optimism
walletconnect send-transaction '{"to":"0x...","value":"0x0","chainId":"eip155:10"}'

# Disconnect
walletconnect disconnect
```

--------------------------------

### List payments with PHP cURL

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments

PHP example using cURL. Configures a GET request with the API key header and prints the response or error.

```php
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.pay.walletconnect.com/v1/payments",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Api-Key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

--------------------------------

### Install WalletConnect CLI SDK and Staking CLI

Source: https://docs.walletconnect.com/agents/overview

Installs the WalletConnect CLI SDK and staking CLI globally via npm.

```bash
npm install -g @walletconnect/cli-sdk @walletconnect/staking-cli
```

--------------------------------

### List payments with JavaScript fetch

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments

JavaScript example using fetch. Sends a GET request with the API key header and logs the JSON response.

```javascript
const options = {method: 'GET', headers: {'Api-Key': '<api-key>'}};

fetch('https://api.pay.walletconnect.com/v1/payments', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Example Implementation with TonConnectUIProvider

Source: https://docs.walletconnect.com/wallets/guides/tonconnect-walletconnect

Complete React example integrating WalletConnect into a TON Connect application. Initializes WalletConnect, creates a `TonConnect` instance with a manifest URL, and wraps the UI with `TonConnectUIProvider` and `TonConnectButton`.

```javascript
import { TonConnect } from '@tonconnect/sdk';
import { initializeWalletConnect } from '@tonconnect/sdk';
import { UniversalConnector } from '@reown/appkit-universal-connector';
import {
  TonConnectUIProvider,
  TonConnectButton,
} from '@tonconnect/ui-react';

// Initialize WalletConnect support
initializeWalletConnect(UniversalConnector, {
  projectId: 'YOUR_PROJECT_ID',
  metadata: {
    name: 'My TON DApp',
    description: 'A decentralized application on TON',
    url: 'https://mytonapp.com',
    icons: ['https://mytonapp.com/icon.png']
  }
});


export function App() {
  // Create TON Connect instance
  const tonConnect = new TonConnect({
    manifestUrl: 'https://mytonapp.com/tonconnect-manifest.json'
  });

  return (
    <div className="pages">
      <h1>WalletConnect + TON React Example</h1>
      <TonConnectUIProvider connector={tonConnect}>
        <TonConnectButton />
      </TonConnectUIProvider>
    </div>
  )
}
```

--------------------------------

### List payments with Python requests

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments

Python example using the requests library. Sends a GET request with the API key header and prints the response.

```python
import requests

url = "https://api.pay.walletconnect.com/v1/payments"

headers = {"Api-Key": "<api-key>"}

response = requests.get(url, headers=headers)

print(response.text)
```

--------------------------------

### Install WalletKit with npm, Yarn, Bun, or pnpm

Source: https://docs.walletconnect.com/wallets/web/installation

Install the WalletKit SDK and its dependencies using your preferred package manager. The commands are equivalent alternatives for npm, Yarn, Bun, and pnpm.

```bash
npm install @reown/walletkit @walletconnect/utils @walletconnect/core
```

```bash
yarn add @reown/walletkit @walletconnect/utils @walletconnect/core
```

```bash
bun add @reown/walletkit @walletconnect/utils @walletconnect/core
```

```bash
pnpm add @reown/walletkit @walletconnect/utils @walletconnect/core
```

--------------------------------

### JavaScript fetch request to get merchant payments

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-merchants-merchant-id-payments

Use this JavaScript fetch example to retrieve merchant payments. Replace {merchant_id} and <api-key> as needed.

```javascript
const options = {method: 'GET', headers: {'X-Api-Key': '<api-key>'}};

fetch('https://api.pay.walletconnect.com/v1/merchants/{merchant_id}/payments', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

--------------------------------

### Initialize WalletKit with Core

Source: https://docs.walletconnect.com/wallets/react-native/usage

Creates a Core instance with projectId and initializes WalletKit with app metadata. The pair function is used later for pairing.

```javascript
import { Core } from "@walletconnect/core";
import { WalletKit } from "@reown/walletkit";

const core = new Core({
  projectId: process.env.PROJECT_ID,
});

const walletKit = await WalletKit.init({
  core, // <- pass the shared `core` instance
  metadata: {
    name: "Demo React Native Wallet",
    description: "Demo RN Wallet to interface with Dapps",
    url: "www.walletconnect.com",
    icons: ["https://your_wallet_icon.png"],
    redirect: {
      native: "yourwalletscheme://",
    },
  },
});

```

--------------------------------

### List payments with Ruby Net::HTTP

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments

Ruby example using Net::HTTP. Sends a GET request with the API key header and prints the response body.

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.pay.walletconnect.com/v1/payments")

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

request = Net::HTTP::Get.new(url)
request["Api-Key"] = '<api-key>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### UniversalConnector Stacks Example

Source: https://docs.walletconnect.com/apps/javascript/installation

Configures a singleton UniversalConnector for the Stacks network. Requires a project ID from the WalletConnect Dashboard; throws an error if not set. Defines a custom Stacks mainnet network and initializes the connector with metadata and network methods.

```javascript
import { UniversalConnector } from '@reown/appkit-universal-connector'

export const projectId = import.meta.env.VITE_PROJECT_ID || "YOUR_PROJECT_ID_HERE" // Replace with your actual project ID

if (!projectId || projectId === "YOUR_PROJECT_ID_HERE") {
  throw new Error('Project ID is not defined. Please set your project ID from the WalletConnect Dashboard.')
}

// you can configure your own network
const stacksMainnet = {
  id: 'stacks-mainnet',
  chainNamespace: 'stacks',
  caipNetworkId: 'stacks:1',
  name: 'Stacks Mainnet',
  nativeCurrency: { name: 'STX', symbol: 'STX', decimals: 6 },
  rpcUrls: { default: { http: ['https://stacks-node-api.mainnet.stacks.co'] } } // Example Stacks Mainnet RPC URL
}

export const networks = [stacksMainnet]

export let universalConnector

export async function getUniversalConnector() {
  if (!universalConnector) {
    universalConnector = await UniversalConnector.init({
      projectId,
      metadata: {
        name: 'Universal Connector',
        description: 'Universal Connector',
        url: 'https://www.walletconnect.com',
        icons: ['https://www.walletconnect.com/icon.png']
      },
      networks: [
        {
          methods: ['stx_signMessage', 'stx_signTransaction', 'stx_getAccounts', 'stx_getAddresses', 'stx_callContract', 'stx_deployContract', 'sendTransfer', 'getAddresses'],
          chains: [stacksMainnet],
          events: ['stx_chainChanged', 'stx_accountsChanged'],
          namespace: 'stacks'
        }
      ]
    })
  }
  return universalConnector
}

```

--------------------------------

### List Payments - Example Response

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-payments

Sample 200 response from the GET /v1/payments endpoint, showing a payment object with merchant, amounts, buyer, transaction, settlement, fees, and stats.

```json
{
  "data": [
    {
      "paymentId": "pay_a1a2ecc101KGF210FP7PN3BK08PZARS1CZ",
      "merchant": {
        "id": "acme-store-1",
        "name": "Acme Store",
        "iconUrl": "https://imagedelivery.net/example/icon.png"
      },
      "referenceId": "a1b2cad4e5f2783012345678axcdea90",
      "status": "succeeded",
      "isTerminal": true,
      "fiatAmount": {
        "unit": "iso4217/USD",
        "value": "500",
        "display": {
          "assetSymbol": "USD",
          "assetName": "US Dollar",
          "decimals": 2
        }
      },
      "tokenAmount": {
        "unit": "caip19/eip155:8453/erc20:0x0000000000000000000000000000000000000000",
        "value": "5000000",
        "display": {
          "assetSymbol": "USDC",
          "assetName": "USD Coin",
          "decimals": 6,
          "networkName": "Base",
          "iconUrl": "https://api.walletconnect.com/assets/v1/image/token/USDC/md",
          "networkIconUrl": "https://api.walletconnect.com/assets/v1/image/network/eip155%3A8453/md"
        }
      },
      "buyer": {
        "accountCaip10": "eip155:8453:0x0000000000000000000000000000000000000000",
        "accountProviderName": "MetaMask",
        "accountProviderIcon": "https://api.walletconnect.com/assets/v1/image/wallet/metamask/md"
      },
      "transaction": {
        "networkId": "8453",
        "hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
        "nonce": 42
      },
      "settlement": {
        "amount": {
          "unit": "caip19/eip155:8453/erc20:0x0000000000000000000000000000000000000000",
          "value": "4840000",
          "display": {
            "assetSymbol": "USDC",
            "assetName": "USD Coin",
            "decimals": 6,
            "iconUrl": "https://api.walletconnect.com/assets/v1/image/token/USDC/md",
            "networkName": "Base",
            "networkIconUrl": "https://api.walletconnect.com/assets/v1/image/network/eip155%3A8453/md"
          }
        },
        "settled": true,
        "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000"
      },
      "fees": {
        "total": {
          "unit": "caip19/eip155:8453/erc20:0x0000000000000000000000000000000000000000",
          "value": "160000",
          "display": {
            "assetSymbol": "USDC",
            "assetName": "USD Coin",
            "decimals": 6,
            "iconUrl": "https://api.walletconnect.com/assets/v1/image/token/USDC/md",
            "networkName": "Base",
            "networkIconUrl": "https://api.walletconnect.com/assets/v1/image/network/eip155%3A8453/md"
          }
        },
        "fixed": {
          "unit": "caip19/eip155:8453/erc20:0x0000000000000000000000000000000000000000",
          "value": "140000",
          "display": {
            "assetSymbol": "USDC",
            "assetName": "USD Coin",
            "decimals": 6,
            "iconUrl": "https://api.walletconnect.com/assets/v1/image/token/USDC/md",
            "networkName": "Base",
            "networkIconUrl": "https://api.walletconnect.com/assets/v1/image/network/eip155%3A8453/md"
          }
        },
        "percentage": "0.4"
      },
      "createdAt": "2024-01-01T12:00:00.000Z",
      "lastUpdatedAt": "2024-01-01T12:00:00.000Z",
      "settledAt": "2024-01-01T12:00:00.000Z"
    }
  ],
  "nextCursor": null,
  "stats": {
    "totalRevenue": [
      {
        "amount": 1000,
        "currency": "USD"
      }
    ],
    "totalTransactions": 100,
    "totalCustomers": 25
  }
}
```

--------------------------------

### List merchants - cURL, Python, JavaScript, PHP, Go, Java, Ruby

Source: https://docs.walletconnect.com/payments/api-reference/2026-02-18/get-v1-merchants

Example requests for the List merchants endpoint. All use the GET method with the Api-Key header and the query parameter limit=20. The endpoint returns a list of merchants with pagination support.

```cURL
curl --request GET \
  --url 'https://api.pay.walletconnect.com/v1/merchants?limit=20' \
  --header 'Api-Key: <api-key>'
```

```Python
import requests

url = "https://api.pay.walletconnect.com/v1/merchants?limit=20"

headers = {"Api-Key": "<api-key>"}

response = requests.get(url, headers=headers)

print(response.text)
```

```JavaScript
const options = {method: 'GET', headers: {'Api-Key': '<api-key>'}};

fetch('https://api.pay.walletconnect.com/v1/merchants?limit=20', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));
```

```PHP
<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.pay.walletconnect.com/v1/merchants?limit=20",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "GET",
  CURLOPT_HTTPHEADER => [
    "Api-Key: <api-key>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}
```

```Go
package main

import (
	"fmt"
	"net/http"
	"io"
)

func main() {

	url := "https://api.pay.walletconnect.com/v1/merchants?limit=20"

	req, _ := http.NewRequest("GET", url, nil)

	req.Header.Add("Api-Key", "<api-key>")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(string(body))

}
```

```Java
HttpResponse<String> response = Unirest.get("https://api.pay.walletconnect.com/v1/merchants?limit=20")
  .header("Api-Key", "<api-key>")
  .asString();
```

```Ruby
require 'uri'
require 'net/http'

url = URI("https://api.pay.walletconnect.com/v1/merchants?limit=20")

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

request = Net::HTTP::Get.new(url)
request["Api-Key"] = '<api-key>'

response = http.request(request)
puts response.read_body
```

--------------------------------

### CLI command reference

Source: https://docs.walletconnect.com/agents/overview

Lists all available CLI commands and options. Use `walletconnect --help` to display this help message.

```bash
Usage: walletconnect <command> [options]

Commands:
  connect                       Connect to a wallet via QR code
  whoami                        Show current session info
  sign <message>                Sign a message with the connected wallet
  sign-typed-data <json>        Sign EIP-712 typed data (JSON string)
  send-transaction <json>       Send a transaction (EVM or Solana)
  swidge                        Bridge/swap tokens across chains via LI.FI
  disconnect                    Disconnect the current session
  config set <k> <v>            Set a config value (e.g. project-id)
  config get <k>                Get a config value

Options:
  --browser            Use browser UI instead of terminal QR code
  --json               Output as JSON (for whoami)
  --chain <id>         Specify chain (e.g. evm, solana, eip155:10) for connect
  --version            Show version number
  --help               Show this help message
```

--------------------------------

### Install Headless SDK packages

Source: https://docs.walletconnect.com/payments/psps/headless-sdk/implementation

Install the Headless SDK packages. The React hook binding `@walletconnect/pay-react` is optional and can be omitted if not using React.

```bash
npm install @walletconnect/pay-core @walletconnect/pay-state \
            @walletconnect/pay-appkit @walletconnect/pay-react

```

--------------------------------

### Process a payment with ReownWalletKit in Flutter

Source: https://docs.walletconnect.com/payments/wallets/walletkit/flutter

Complete example of processing a payment using ReownWalletKit in Flutter. It covers getting payment options, selecting an option, collecting data via WebView if required, fetching required payment actions, executing wallet actions, confirming the payment, and polling until a final status. Note that the WebView data collection must happen before fetching required payment actions; otherwise the backend rejects with 400 "IC data required". The example also includes a placeholder getWalletAccounts() method that should return CAIP-10 formatted accounts.

```dart
import 'package:reown_walletkit/reown_walletkit.dart';

class PaymentService {
  final ReownWalletKit walletKit;

  PaymentService(this.walletKit);

  /// Process a payment from a payment link (e.g., after scanning QR code)
  Future<void> processPayment(String paymentLink) async {
    try {
      // Step 1: Get payment options
      final accounts = await getWalletAccounts(); // Your wallet accounts
      final optionsResponse = await walletKit.getPaymentOptions(
        request: GetPaymentOptionsRequest(
          paymentLink: paymentLink,
          accounts: accounts,
          includePaymentInfo: true,
        ),
      );

      if (optionsResponse.options.isEmpty) {
        throw Exception('No payment options available');
      }

      // Step 2: Select payment option (or let user choose)
      PaymentOption selectedOption = optionsResponse.options.first;
      final paymentId = optionsResponse.paymentId;
      final optionId = selectedOption.id;

      // Step 3: Collect data via WebView if required for selected option.
      // This must happen BEFORE fetching the required payment actions —
      // the backend rejects the actions request with 400 "IC data required"
      // for options needing Information Capture if data wasn't collected first.
      // The WebView submits the data directly to the backend, so it is NOT
      // passed to confirmPayment later.
      if (selectedOption.collectData?.url != null) {
        await showDataCollectionWebView(selectedOption.collectData!.url);
      }

      // Step 4: Get required payment actions (if not already in the option)
      List<Action> actions = selectedOption.actions;
      if (actions.isEmpty) {
        actions = await walletKit.getRequiredPaymentActions(
          request: GetRequiredPaymentActionsRequest(
            optionId: optionId,
            paymentId: paymentId,
          ),
        );
      }

      // Step 5: Execute wallet actions and collect the results
      final data = <Object>[];
      for (final action in actions) {
        // Dispatch based on action.walletRpc.method:
        // 'eth_signTypedData_v4' -> sign EIP-712 typed data
        // 'eth_sendTransaction'  -> send transaction (e.g., token approval)
        // 'personal_sign'        -> personal message signing
        data.add(await signAction(action.walletRpc));
      }

      // Step 6: Confirm payment
      ConfirmPaymentResponse confirmResponse = await walletKit.confirmPayment(
        request: ConfirmPaymentRequest(
          paymentId: paymentId,
          optionId: optionId,
          data: data,
          maxPollMs: 60000, // Maximum polling time in milliseconds
        ),
      );

      // Step 7: Poll until final status (if needed)
      while (!confirmResponse.isFinal && confirmResponse.pollInMs != null) {
        await Future.delayed(Duration(milliseconds: confirmResponse.pollInMs!));
        confirmResponse = await walletKit.confirmPayment(
          request: ConfirmPaymentRequest(
            paymentId: paymentId,
            optionId: optionId,
            data: data,
            maxPollMs: 60000,
          ),
        );
      }

      // Handle final payment status
      switch (confirmResponse.status) {
        case PaymentStatus.succeeded:
          print('Payment succeeded!');
          break;
        case PaymentStatus.failed:
          throw Exception('Payment failed');
        case PaymentStatus.expired:
          throw Exception('Payment expired');
        case PaymentStatus.cancelled:
          throw Exception('Payment cancelled');
        case PaymentStatus.requires_action:
          throw Exception('Payment requires additional action');
        case PaymentStatus.processing:
          // Should not happen if isFinal is true
          break;
      }
    } catch (e) {
      print('Payment error: $e');
      rethrow;
    }
  }

  Future<List<String>> getWalletAccounts() async {
    // Return your wallet's CAIP-10 formatted accounts
    // Example: ['eip155:1:0x1234...', 'eip155:137:0x5678...']
    return [];
  }
}

```
Tokens:
Raw