Integrate Urontopay payments with confidence.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;

class PaymentController extends Controller
{
    public function create(Request $request)
    {
        $validated = $request->validate([
            'amount' => ['required', 'numeric', 'min:0.01', 'max:1000000'],
            'email'  => ['nullable', 'email'],
        ]);

        $response = Http::acceptJson()
            ->asJson()
            ->withHeaders([
                'CLIENT-ID'  => config('services.urontopay.client_id'),
                'SECRET-KEY' => config('services.urontopay.secret_key'),
                'BRAND-KEY'  => config('services.urontopay.brand_key'),
            ])
            ->connectTimeout(10)
            ->timeout(30)
            ->post(config('services.urontopay.base_url') . '/api/payment/create', [
                'amount'      => $validated['amount'],
                'cus_name'    => $request->user()->name ?? 'Customer',
                'cus_email'   => $validated['email'] ?? null,
                'success_url' => route('payment.success'),
                'cancel_url'  => route('payment.cancel'),
                'webhook_url' => route('payment.webhook'),
                'return_type' => 'GET',
                'metadata'    => ['order_id' => 'ORDER-1001'],
            ]);

        $response->throw();

        return redirect()->away($response->json('payment_url'));
    }
}

const baseUrl = process.env.URONTOPAY_BASE_URL.replace(/\/$/, '');

async function createPayment() {
  const response = await fetch(`${baseUrl}/api/payment/create`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'CLIENT-ID': process.env.URONTOPAY_CLIENT_ID,
      'SECRET-KEY': process.env.URONTOPAY_SECRET_KEY,
      'BRAND-KEY': process.env.URONTOPAY_BRAND_KEY,
    },
    body: JSON.stringify({
      amount: 500,
      cus_name: 'Customer Name',
      cus_email: 'customer@example.com',
      success_url: 'https://merchant.example/payment/success',
      cancel_url: 'https://merchant.example/payment/cancel',
      webhook_url: 'https://merchant.example/webhooks/urontopay',
      return_type: 'GET',
      metadata: { order_id: 'ORDER-1001' },
    }),
    signal: AbortSignal.timeout(30000),
  });

  const data = await response.json();

  if (!response.ok || !data.payment_url) {
    throw new Error(data.message || 'Unable to create payment');
  }

  return data.payment_url;
}

createPayment()
  .then((paymentUrl) => console.log(paymentUrl))
  .catch((error) => console.error(error.message));

import os
import requests

base_url = os.environ["URONTOPAY_BASE_URL"].rstrip("/")

headers = {
    "Content-Type": "application/json",
    "CLIENT-ID": os.environ["URONTOPAY_CLIENT_ID"],
    "SECRET-KEY": os.environ["URONTOPAY_SECRET_KEY"],
    "BRAND-KEY": os.environ["URONTOPAY_BRAND_KEY"],
}

payload = {
    "amount": 500,
    "cus_name": "Customer Name",
    "cus_email": "customer@example.com",
    "success_url": "https://merchant.example/payment/success",
    "cancel_url": "https://merchant.example/payment/cancel",
    "webhook_url": "https://merchant.example/webhooks/urontopay",
    "return_type": "GET",
    "metadata": {"order_id": "ORDER-1001"},
}

response = requests.post(
    f"{base_url}/api/payment/create",
    json=payload,
    headers=headers,
    timeout=30,
)
response.raise_for_status()

data = response.json()
if not data.get("payment_url"):
    raise RuntimeError(data.get("message", "Unable to create payment"))

print(data["payment_url"])

<form method="POST" action="/payments/create">
  <label for="amount">Amount</label>
  <input
    id="amount"
    type="number"
    name="amount"
    min="0.01"
    step="0.01"
    required
  >

  <label for="email">Email</label>
  <input
    id="email"
    type="email"
    name="email"
    autocomplete="email"
  >

  <button type="submit">Pay securely</button>
</form>

<!--
  /payments/create is your own secure backend route.
  Do not include CLIENT-ID, SECRET-KEY, or BRAND-KEY in this file.
-->

public function verify(Request $request)
{
    $transactionId = $request->input('transactionId')
        ?? $request->input('transaction_id');

    abort_unless($transactionId, 400, 'Missing transaction ID.');

    $response = Http::acceptJson()
        ->asJson()
        ->withHeaders([
            'CLIENT-ID'  => config('services.urontopay.client_id'),
            'SECRET-KEY' => config('services.urontopay.secret_key'),
            'BRAND-KEY'  => config('services.urontopay.brand_key'),
        ])
        ->timeout(30)
        ->post(config('services.urontopay.base_url') . '/api/payment/verify', [
            'transaction_id' => $transactionId,
        ]);

    $response->throw();
    $payment = $response->json();

    if (($payment['status'] ?? null) !== 'COMPLETED') {
        return redirect()->route('payment.failed');
    }

    // Compare verified amount and metadata.order_id with your order.
    return redirect()->route('payment.success');
}

async function verifyPayment(transactionId) {
  const baseUrl = process.env.URONTOPAY_BASE_URL.replace(/\/$/, '');

  const response = await fetch(`${baseUrl}/api/payment/verify`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'CLIENT-ID': process.env.URONTOPAY_CLIENT_ID,
      'SECRET-KEY': process.env.URONTOPAY_SECRET_KEY,
      'BRAND-KEY': process.env.URONTOPAY_BRAND_KEY,
    },
    body: JSON.stringify({ transaction_id: transactionId }),
    signal: AbortSignal.timeout(30000),
  });

  const payment = await response.json();
  if (!response.ok) {
    throw new Error(payment.message || 'Verification failed');
  }

  return payment;
}

const payment = await verifyPayment('UP123456');
if (payment.status === 'COMPLETED') {
  console.log('Payment verified', payment);
}

import os
import requests

base_url = os.environ["URONTOPAY_BASE_URL"].rstrip("/")
headers = {
    "Content-Type": "application/json",
    "CLIENT-ID": os.environ["URONTOPAY_CLIENT_ID"],
    "SECRET-KEY": os.environ["URONTOPAY_SECRET_KEY"],
    "BRAND-KEY": os.environ["URONTOPAY_BRAND_KEY"],
}

response = requests.post(
    f"{base_url}/api/payment/verify",
    json={"transaction_id": "UP123456"},
    headers=headers,
    timeout=30,
)
response.raise_for_status()
payment = response.json()

if payment.get("status") == "COMPLETED":
    print("Payment verified", payment)
else:
    print("Payment is not completed", payment.get("status"))

curl --request POST 'https://pay1.urontopay.com/api/payment/verify' \
  --header 'Content-Type: application/json' \
  --header 'CLIENT-ID: YOUR_CLIENT_ID' \
  --header 'SECRET-KEY: YOUR_SECRET_KEY' \
  --header 'BRAND-KEY: YOUR_BRAND_KEY' \
  --data '{
    "transaction_id": "UP123456"
  }'