Build Payments
That Scale Globally

import { useEffect } from 'react';
 
// Load SDK once in index.html or via useEffect
export default function CheckoutButton({ product, customer }) {
 
  useEffect(() => {
    const script = document.createElement('script');
    script.src = 'https://api.usesnappay.com/finalpay-sdk.js';
    document.body.appendChild(script);
    return () => document.body.removeChild(script);
  }, []);
 
  const handleCheckout = () => {
    window.FinalPay.initialize({
      apikey:      process.env.REACT_APP_SNAPPAY_KEY,
      business_id: process.env.REACT_APP_BUSINESS_ID,
      mode: 'LIVE',
    });
 
    window.FinalPay.openCheckout({
      transaction_id: `TRX-${Date.now()}`,
      amount:         product.priceInCents,
      currency:       product.currency,
      description:   product.name,
      customer_name: customer.name,
    });
 
    window.FinalPay.onPaymentResponse((data) => {
      if (data.status === 'ACCEPTED') {
        window.location.href = `/success?ref=${data.reference}`;
      } else if (data.status === 'REFUSED') {
        alert(data.message);
      }
    });
 
    window.FinalPay.onError((err) => console.error(err));
  };
 
  return (
    <button onClick={handleCheckout}>
      Pay {product.currency} {(product.priceInCents / 100).toFixed(2)}
    </button>
  );
}

<!-- Vue 3 Composition API -->
<template>
  <button @click="checkout">Pay {{ (amount / 100).toFixed(2) }} {{ currency }}</button>
</template>
 
<script setup>
import { onMounted } from 'vue'
 
const props = defineProps(['amount', 'currency', 'description'])
 
onMounted(() => {
  const s = document.createElement('script')
  s.src = 'https://api.usesnappay.com/finalpay-sdk.js'
  document.body.appendChild(s)
})
 
function checkout() {
  window.FinalPay.initialize({
    apikey:      import.meta.env.VITE_SNAPPAY_KEY,
    business_id: import.meta.env.VITE_BUSINESS_ID,
    mode: 'LIVE',
  })
 
  window.FinalPay.openCheckout({
    transaction_id: `TRX-${Date.now()}`,
    amount:         props.amount,
    currency:       props.currency,
    description:   props.description,
  })
 
  window.FinalPay.onPaymentResponse((data) => {
    if (data.status === 'ACCEPTED')
      window.location.href = `/success?ref=${data.reference}`
    else if (data.status === 'REFUSED')
      alert(data.message)
  })
 
  window.FinalPay.onError((e) => console.error(e))
}
</script>

// Install: npm install axios

const axios = require('axios');

async function checkPayment(transactionId) {
  try {
    const { data } = await axios.post(
      'https://api.usesnappay.com/payment/check',
      {
        api_key:        process.env.SNAPPAY_API_KEY,
        business_id:    42,
        transaction_id: transactionId,
      },
      { headers: { 'Content-Type': 'application/json' } }
    );

    switch (data.status) {
      case 'success':
        console.log(` Paid by ${data.customer_name} — ${data.amount} ${data.currency}`);
        break;
      case 'requires_action':
        console.log('3D Secure required');
        break;
      case 'processing':
        console.log(' Processing...');
        setTimeout(() => checkPayment(transactionId), 3000);
        break;
      case 'failed':
        console.log('Payment failed');
        break;
    }
  } catch (err) {
    console.error('SnapPay error:', err.response?.data ?? err.message);
  }
}

checkPayment('order_ABC123');

# Install: pip install requests

import os
import requests

BASE_URL = "https://api.usesnappay.com"

def check_payment(transaction_id: str) -> dict:
    payload = {
        "api_key":        os.getenv("SNAPPAY_API_KEY"),
        "business_id":    42,
        "transaction_id": transaction_id,
    }
    response = requests.post(
        f"{BASE_URL}/payment/check",
        json=payload,
        timeout=10,
    )
    response.raise_for_status()
    data = response.json()

    status = data.get("status")
    if status == "success":
        print(f" Confirmed — {data['customer_name']} paid {data['amount']} {data['currency']}")
    elif status == "requires_action":
        print("3DS authentication required")
    elif status == "processing":
        print(" Still processing...")
    elif status == "failed":
        print("Payment failed or cancelled")
    else:
        print(f"? Unknown status: {status}")

    return data

if __name__ == "__main__":
    check_payment("order_ABC123")

// Browser — Vanilla JavaScript (fetch API)
// Never expose your api_key in frontend code!

async function checkPayment(transactionId) {
  const res = await fetch('https://api.usesnappay.com/payment/check', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      api_key:        'spay_test_your_key',
      business_id:    42,
      transaction_id: transactionId,
    }),
  });

  if (!res.ok) throw new Error(`HTTP ${res.status}`);
  const data = await res.json();

  const handlers = {
    success:         () => console.log('Payment confirmed ', data),
    requires_action: () => console.log('3DS required ', data),
    processing:      () => setTimeout(() => checkPayment(transactionId), 3000),
    failed:          () => console.log('Payment failed '),
  };

  (handlers[data.status] ?? (() => console.warn('Unknown status', data)))();
}

checkPayment('order_ABC123');

// Java 11+ — HttpClient (no external dependency)

import java.net.URI;
import java.net.http.*;
import java.net.http.HttpResponse.BodyHandlers;

public class SnapPayClient {
    private static final String BASE_URL = "https://api.usesnappay.com";
    private static final HttpClient client = HttpClient.newHttpClient();

    public static String checkPayment(String transactionId) throws Exception {
        String body = String.format("""
            {"api_key":"%s","business_id":42,"transaction_id":"%s"}
            """, System.getenv("SNAPPAY_API_KEY"), transactionId);

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(BASE_URL + "/payment/check"))
            .header("Content-Type", "application/json")
            .POST(HttpRequest.BodyPublishers.ofString(body))
            .build();

        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
        System.out.println(response.body());
        return response.body();
    }

    public static void main(String[] args) throws Exception {
        checkPayment("order_ABC123");
    }
}

// Kotlin — OkHttp  |  build.gradle: implementation("com.squareup.okhttp3:okhttp:4.12.0")

import okhttp3.*
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.RequestBody.Companion.toRequestBody
import org.json.JSONObject

val client = OkHttpClient()
val JSON_MT = "application/json; charset=utf-8".toMediaType()

fun checkPayment(transactionId: String): String {
    val payload = JSONObject().apply {
        put("api_key",        System.getenv("SNAPPAY_API_KEY"))
        put("business_id",    42)
        put("transaction_id", transactionId)
    }.toString()

    val request = Request.Builder()
        .url("https://api.usesnappay.com/payment/check")
        .post(payload.toRequestBody(JSON_MT))
        .addHeader("Accept", "application/json")
        .build()

    client.newCall(request).execute().use { response ->
        val body = response.body?.string() ?: ""
        when (JSONObject(body).getString("status")) {
            "success"         -> println(" Payment confirmed")
            "requires_action" -> println("3DS required")
            "processing"      -> println(" Processing...")
            "failed"          -> println("Failed")
        }
        return body
    }
}

fun main() = checkPayment("order_ABC123")

// C# / .NET 6+ — System.Net.Http (built-in)

using System.Net.Http.Json;
using System.Text.Json;

var http = new HttpClient { BaseAddress = new Uri("https://api.usesnappay.com") };

async Task CheckPaymentAsync(string transactionId) {
    var payload = new {
        api_key        = Environment.GetEnvironmentVariable("SNAPPAY_API_KEY"),
        business_id    = 42,
        transaction_id = transactionId,
    };

    var response = await http.PostAsJsonAsync("/payment/check", payload);
    response.EnsureSuccessStatusCode();

    var json = await response.Content.ReadFromJsonAsync<JsonDocument>();
    var status = json!.RootElement.GetProperty("status").GetString();

    switch (status) {
        case "success":         Console.WriteLine(" Payment confirmed"); break;
        case "requires_action": Console.WriteLine("3DS required"); break;
        case "processing":      Console.WriteLine(" Processing..."); break;
        case "failed":          Console.WriteLine("Payment failed"); break;
    }
}

await CheckPaymentAsync("order_ABC123");

// Go — standard library only

package main

import (
    "bytes"; "encoding/json"; "fmt"; "net/http"; "os"
)

type CheckRequest  struct { APIKey string `json:"api_key"`; BusinessID int `json:"business_id"`; TransactionID string `json:"transaction_id"` }
type CheckResponse struct { Status string `json:"status"`; TxRef string `json:"transaction_ref"`; Amount int `json:"amount"` }

func checkPayment(txID string) (*CheckResponse, error) {
    b, _ := json.Marshal(CheckRequest{os.Getenv("SNAPPAY_API_KEY"), 42, txID})
    resp, err := http.Post("https://api.usesnappay.com/payment/check", "application/json", bytes.NewBuffer(b))
    if err != nil { return nil, err }
    defer resp.Body.Close()
    var r CheckResponse
    json.NewDecoder(resp.Body).Decode(&r)
    return &r, nil
}

func main() {
    r, _ := checkPayment("order_ABC123")
    fmt.Printf("Status: %s | Ref: %s\n", r.Status, r.TxRef)
}

# Ruby — net/http (standard library)

require 'net/http'
require 'json'
require 'uri'

def check_payment(transaction_id)
  uri  = URI.parse('https://api.usesnappay.com/payment/check')
  http = Net::HTTP.new(uri.host, uri.port)
  req  = Net::HTTP::Post.new(uri.request_uri)
  req['Content-Type'] = 'application/json'
  req.body = { api_key: ENV['SNAPPAY_API_KEY'], business_id: 42, transaction_id: transaction_id }.to_json

  data = JSON.parse(http.request(req).body)

  case data['status']
  when 'success'         then puts " Paid by #{data['customer_name']}"
  when 'requires_action' then puts '3DS required'
  when 'processing'      then puts ' Processing...'
  when 'failed'          then puts 'Payment failed'
  end
end

check_payment('order_ABC123')

// Swift 5.5+ — URLSession + async/await

import Foundation

struct PayCheckRequest: Codable {
    let apiKey: String; let businessId: Int; let transactionId: String
    enum CodingKeys: String, CodingKey {
        case apiKey = "api_key"; case businessId = "business_id"; case transactionId = "transaction_id"
    }
}

func checkPayment(transactionId: String) async throws {
    var req = URLRequest(url: URL(string: "https://api.usesnappay.com/payment/check")!)
    req.httpMethod = "POST"
    req.setValue("application/json", forHTTPHeaderField: "Content-Type")
    req.httpBody = try JSONEncoder().encode(PayCheckRequest(
        apiKey:        ProcessInfo.processInfo.environment["SNAPPAY_API_KEY"] ?? "",
        businessId:    42,
        transactionId: transactionId
    ))

    let (data, _) = try await URLSession.shared.data(for: req)
    let json = try JSONSerialization.jsonObject(with: data) as? [String: Any]

    switch json?["status"] as? String {
    case "success":         print(" Payment confirmed")
    case "requires_action": print("3DS required")
    case "processing":      print(" Processing...")
    case "failed":          print("Payment failed")
    default:                print("? Unknown status")
    }
}

// Dart / Flutter — http package  |  pubspec.yaml: http: ^1.2.0

import 'dart:convert';
import 'package:http/http.dart' as http;

Future<void> checkPayment(String transactionId) async {
  final response = await http.post(
    Uri.parse('https://api.usesnappay.com/payment/check'),
    headers: {'Content-Type': 'application/json'},
    body: jsonEncode({
      'api_key':        const String.fromEnvironment('SNAPPAY_API_KEY'),
      'business_id':    42,
      'transaction_id': transactionId,
    }),
  );

  if (response.statusCode >= 400) throw Exception('HTTP ${response.statusCode}');

  switch (jsonDecode(response.body)['status']) {
    case 'success':         print(' Confirmed'); break;
    case 'requires_action': print('3DS required'); break;
    case 'processing':      print(' Processing...'); break;
    case 'failed':          print('Payment failed'); break;
  }
}

void main() => checkPayment('order_ABC123');

# cURL — Quick testing

curl -X POST "https://api.usesnappay.com/payment/check" \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -d '{
    "api_key":        "spay_test_your_api_key_here",
    "business_id":    42,
    "transaction_id": "order_ABC123"
  }'

# Pretty-print with jq
curl -s -X POST "https://api.usesnappay.com/payment/check" \
  -H "Content-Type: application/json" \
  -d '{"api_key":"spay_test_your_api_key_here","business_id":42,"transaction_id":"order_ABC123"}' \
  | jq .

<?php
    // Récupérer le payload brut et la signature
    $payload   = file_get_contents('php://input');
    $signature = $_SERVER['HTTP_X_SNAPPAY_SIGNATURE'] ?? '';
    $apiKey    = 'your_api_key'; // votre clé API SnapPay

    // Calculer la signature attendue
    $expected = 'sha256=' . hash_hmac('sha256', $payload, $apiKey);

    // Comparer de manière sécurisée (timing-safe)
    if (!hash_equals($expected, $signature)) {
        http_response_code(401);
        exit('Invalid signature');
    }

    // Signature valide — traiter le webhook
    $data = json_decode($payload, true);

    switch ($data['event']) {
        case 'payment.success':
            // Valider la commande
            break;
        case 'payment.failed':
            // Notifier le client
            break;
        case 'payment.requires_action':
            // Rediriger vers 3DS
            break;
    }

    http_response_code(200);
    echo json_encode(['received' => true]);

const crypto = require('crypto');

    function verifyWebhook(rawBody, signature, apiKey) {
    const expected = 'sha256=' + crypto
        .createHmac('sha256', apiKey)
        .update(rawBody)
        .digest('hex');

    // Timing-safe comparison
    return crypto.timingSafeEqual(
        Buffer.from(expected),
        Buffer.from(signature)
    );
    }

    // Express.js example
    app.post('/webhook/snappay', express.raw({type: 'application/json'}), (req, res) => {
    const signature = req.headers['x-snappay-signature'];
    const apiKey    = 'your_api_key';

    if (!verifyWebhook(req.body, signature, apiKey)) {
        return res.status(401).json({error: 'Invalid signature'});
    }

    const data = JSON.parse(req.body);
    console.log(`Event: ${data.event} — Ref: ${data.transaction_ref}`);

    res.status(200).json({received: true});
    });

import hmac
import hashlib
import json

def verify_webhook(raw_body: bytes, signature: str, api_key: str) -> bool:
    expected = 'sha256=' + hmac.new(
        api_key.encode(),
        raw_body,
        hashlib.sha256
    ).hexdigest()
    # Timing-safe comparison
    return hmac.compare_digest(expected, signature)

# Flask example
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/webhook/snappay', methods=['POST'])
def handle_webhook():
    signature = request.headers.get('X-SnapPay-Signature', '')
    api_key   = 'your_api_key'

    if not verify_webhook(request.data, signature, api_key):
        return jsonify({'error': 'Invalid signature'}), 401

    data = request.get_json()
    print(f"Event: {data['event']} — Ref: {data['transaction_ref']}")

    return jsonify({'received': True}), 200