Python API Integration Integration

1📦 Installation via pip

pip install binance-and-crypto-payment python-dotenv

2🔑 Get Your API Keys (Free)

• Sign up at dash.payerurl.com — takes under 2 minutes, no credit card required
• Go to Dashboard → Get API Credentials
• Copy your Public Key and Secret Key

3🔐 Secure Configuration

Create a .env file in your project root and add it to .gitignore:

PAYERURL_PUBLIC_KEY=your_public_key
PAYERURL_SECRET_KEY=your_secret_key
BASE_URL=https://yourdomain.com

4🚀 Quick Start

import os
import time
from dotenv import load_dotenv
from binance_and_crypto_payment import CryptoPaymentClient
load_dotenv()

client = CryptoPaymentClient(
    public_key=os.getenv("PAYERURL_PUBLIC_KEY"),
    secret_key=os.getenv("PAYERURL_SECRET_KEY")
)
BASE_URL = os.getenv("BASE_URL", "http://localhost:8000").rstrip("/")

items = [{"name": "Product", "qty": "1", "price": "10.00"}]

data = {
    "first_name":   "John",
    "last_name":    "Doe",
    "email":        "[email protected]",
    "redirect_url": f"{BASE_URL}/payment/success/",
    "notify_url":   f"{BASE_URL}/payment/notify/",
    "cancel_url":   f"{BASE_URL}/payment/cancel/",
}

response = client.payment(
    invoice_id=f"PYP-{int(time.time())}",
    amount=10.00,
    currency="USD",
    items=items,
    data=data
)

payment_url = response["redirect_to"]
print(payment_url)  # Redirect customer here

5🔗 Django Integration

Checkout view, success/cancel callbacks, and webhook handler:

# views.py
from django.views import View
from django.http import JsonResponse, HttpResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from binance_and_crypto_payment import CryptoPaymentClient, CryptoPaymentNotify, CryptoPaymentException

class CheckoutView(View):
    def post(self, request):
        client = CryptoPaymentClient(public_key=PUBLIC_KEY, secret_key=SECRET_KEY)
        response = client.payment(
            invoice_id=f"PYP-{int(time.time())}",
            amount=float(request.POST.get("amount", 10.00)),
            currency="USD",
            items=[{"name": "Order", "qty": "1", "price": request.POST.get("amount", "10.00")}],
            data={
                "first_name":   request.user.first_name,
                "last_name":    request.user.last_name,
                "email":        request.user.email,
                "redirect_url": f"{BASE_URL}/payment/success/",
                "notify_url":   f"{BASE_URL}/payment/notify/",
                "cancel_url":   f"{BASE_URL}/payment/cancel/",
            }
        )
        return redirect(response["redirect_to"])

@csrf_exempt
@require_POST
def notify_payerurl(request):
    notify = CryptoPaymentNotify(public_key=PUBLIC_KEY, secret_key=SECRET_KEY)
    try:
        result = notify.process(request)
    except CryptoPaymentException as e:
        return JsonResponse({"status": e.code, "message": e.message}, status=200)

    if result["type"] == "cancelled":
        return JsonResponse({"status": 20000, "message": "Order cancelled"}, status=200)

    data = result["data"]
    # YOUR BUSINESS LOGIC HERE
    # data["order_id"], data["transaction_id"], data["confirm_rcv_amnt"]
    return JsonResponse({"status": 2040, "message": "Payment processed successfully"}, status=200)

# urls.py
urlpatterns = [
    path("payment/checkout/", CheckoutView.as_view(), name="checkout"),
    path("payment/success/",  payment_success,        name="payment_success"),
    path("payment/cancel/",   payment_cancel,         name="payment_cancel"),
    path("payment/notify/",   notify_payerurl,        name="payment_notify"),
]

6🔗 Flask Integration

from flask import Flask, request, redirect, jsonify
from binance_and_crypto_payment import CryptoPaymentClient, CryptoPaymentNotify, CryptoPaymentException

app = Flask(__name__)

@app.route("/payment/checkout/", methods=["POST"])
def checkout():
    client = CryptoPaymentClient(public_key=PUBLIC_KEY, secret_key=SECRET_KEY)
    response = client.payment(
        invoice_id=f"PYP-{int(time.time())}",
        amount=float(request.form.get("amount", 10.00)),
        currency="USD",
        items=[{"name": "Order", "qty": "1", "price": request.form.get("amount", "10.00")}],
        data={
            "first_name":   request.form.get("first_name"),
            "last_name":    request.form.get("last_name"),
            "email":        request.form.get("email"),
            "redirect_url": f"{BASE_URL}/payment/success/",
            "notify_url":   f"{BASE_URL}/payment/notify/",
            "cancel_url":   f"{BASE_URL}/payment/cancel/",
        }
    )
    return redirect(response["redirect_to"])

@app.route("/payment/notify/", methods=["POST"])
def notify_payerurl():
    notify = CryptoPaymentNotify(public_key=PUBLIC_KEY, secret_key=SECRET_KEY)
    try:
        result = notify.process(request)
    except CryptoPaymentException as e:
        return jsonify({"status": e.code, "message": e.message}), 200

    if result["type"] == "cancelled":
        return jsonify({"status": 20000, "message": "Order cancelled"}), 200

    data = result["data"]
    # YOUR BUSINESS LOGIC HERE
    return jsonify({"status": 2040, "message": "Payment processed successfully"}), 200

7🔗 FastAPI Integration

from fastapi import FastAPI, Request, Form
from fastapi.responses import JSONResponse, RedirectResponse
from binance_and_crypto_payment import CryptoPaymentClient, CryptoPaymentNotify, CryptoPaymentException

app = FastAPI()

@app.post("/payment/checkout/")
async def checkout(amount: float = Form(...), first_name: str = Form(...),
                   last_name: str = Form(...), email: str = Form(...)):
    client = CryptoPaymentClient(public_key=PUBLIC_KEY, secret_key=SECRET_KEY)
    response = client.payment(
        invoice_id=f"PYP-{int(time.time())}",
        amount=amount, currency="USD",
        items=[{"name": "Order", "qty": "1", "price": str(amount)}],
        data={
            "first_name": first_name, "last_name": last_name, "email": email,
            "redirect_url": f"{BASE_URL}/payment/success/",
            "notify_url":   f"{BASE_URL}/payment/notify/",
            "cancel_url":   f"{BASE_URL}/payment/cancel/",
        }
    )
    return RedirectResponse(url=response["redirect_to"])

@app.post("/payment/notify/")
async def notify_payerurl(request: Request):
    notify = CryptoPaymentNotify(public_key=PUBLIC_KEY, secret_key=SECRET_KEY)
    try:
        result = notify.process(request)
    except CryptoPaymentException as e:
        return JSONResponse({"status": e.code, "message": e.message}, status_code=200)

    if result["type"] == "cancelled":
        return JSONResponse({"status": 20000, "message": "Order cancelled"}, status_code=200)

    data = result["data"]
    # YOUR BUSINESS LOGIC HERE
    return JSONResponse({"status": 2040, "message": "Payment processed successfully"}, status_code=200)

uvicorn main:app --reload