Metadata-Version: 2.4
Name: binance-and-crypto-payment
Version: 0.1.23
Summary: Accept Binance QR code, Bitcoin, USDT, USDC Pay directly into your wallet — no merchant account, no KYC, 10-minute Python integration
Author-email: PayerURL <info@payerurl.com>
License: MIT
Project-URL: Homepage, https://payerurl.com
Project-URL: Documentation, https://python.payerurl.com
Project-URL: Repository, https://github.com/payerurl/binance-and-crypto-payment
Project-URL: Bug Tracker, https://github.com/payerurl/binance-and-crypto-payment/issues
Project-URL: Live Demo, https://python.payerurl.com
Project-URL: Dashboard, https://dash.payerurl.com
Keywords: crypto,bitcoin,binance,coinbase,crypto-payment,django-payment,flask-payment,credit-card-to-crypto
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Financial and Insurance Industry
Classifier: Topic :: Office/Business :: Financial
Classifier: Topic :: Office/Business :: Financial :: Point-Of-Sale
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Internet :: WWW/HTTP
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Python :: 3.13
Classifier: Operating System :: OS Independent
Classifier: Natural Language :: English
Requires-Python: >=3.8
Description-Content-Type: text/markdown
Requires-Dist: requests

# 🪙 Binance & Crypto Payment Gateway for Python

> Accept Bitcoin, USDT, USDC, ETH, and BNB payments directly into your wallet — no middleman, no merchant account, no KYC required.

**Powered by [PayerURL](https://payerurl.com)** — the direct-to-wallet crypto payment processor for Python developers.

[![PyPI Version](https://img.shields.io/pypi/v/binance-and-crypto-payment?color=orange)](https://pypi.org/project/binance-and-crypto-payment/)
[![PyPI Downloads](https://img.shields.io/pypi/dm/binance-and-crypto-payment?color=blue)](https://pypi.org/project/binance-and-crypto-payment/)
[![Python Versions](https://img.shields.io/pypi/pyversions/binance-and-crypto-payment)](https://pypi.org/project/binance-and-crypto-payment/)
[![License](https://img.shields.io/pypi/l/binance-and-crypto-payment?color=green)](https://opensource.org/licenses/MIT)
[![GitHub Stars](https://img.shields.io/github/stars/muhitmonsur/binance-and-crypto-payment?style=social)](https://github.com/muhitmonsur/binance-and-crypto-payment)

🔴 **[LIVE DEMO](https://python.payerurl.com/)** | 🔑 **[Get API Key](https://dash.payerurl.com)** | 💬 **[Telegram Support](https://t.me/Payerurl)**

---

## ✅ Why Developers Choose This Package

| Feature | Detail |
|---|---|
| 🏦 **No merchant account needed** | Payments go directly to your crypto wallet |
| 🌍 **169+ fiat currencies** | USD, EUR, GBP, CAD and more — converted at live rates |
| ⚡ **10-minute integration** | Simple API, clear docs, copy-paste code |
| 🔒 **No KYC for withdrawals** | Basic accounts withdraw without identity verification |
| 📱 **Binance QR Code payments** | Customers scan and pay without leaving your app |
| 💸 **Zero hidden fees** | No network surcharges or platform fees |
| 🛠️ **Django, Flask & FastAPI ready** | Works with any Python web framework |

---

## 📦 Installation

```bash
pip install binance-and-crypto-payment
```

---

## 🔑 Get Your API Key (Free)

1. Sign up at **[dash.payerurl.com](https://dash.payerurl.com)**
2. Go to **Dashboard → Get API Credentials**
3. Copy your **Public Key** and **Secret Key**

> 👉 Registration is free and takes under 2 minutes. No credit card required.

---

## 🚀 Quick Start

```python
from binance_and_crypto_payment import CryptoPaymentClient
import time

client = CryptoPaymentClient(
    public_key="YOUR_PUBLIC_KEY",   # from dash.payerurl.com
    secret_key="YOUR_SECRET_KEY"    # from dash.payerurl.com
)

response = client.payment(
    invoice_id=f"PYP-{int(time.time())}",
    amount=10.00,
    currency="USD",
    items=[{"name": "Product", "qty": "1", "price": "10.00"}],
    data={
        "first_name": "John",
        "last_name": "Doe",
        "email": "john@example.com",
        "redirect_url": "https://yoursite.com/payment/success",  # redirect after payment
        "notify_url":   "https://yoursite.com/payment/notify",   # webhook: receives payment result
        "cancel_url":   "https://yoursite.com/payment/cancel",   # redirect if customer cancels
    }
)

print(response)
# {'status': True, 'redirect_to': 'https://api-v2.payerurl.com/web-payment-option/PYP...'}

# Redirect the customer to the payment page
payment_url = response["redirect_to"]
```

> Replace `yoursite.com` with your actual domain. All three URLs must be publicly accessible endpoints on your server.

---

## 🌐 Supported Cryptocurrencies & Networks

| Currency | Networks |
|---|---|
| **USDT** | TRC20 (Tron), ERC20 (Ethereum), BEP20 (BSC) |
| **USDC** | ERC20 (Ethereum), BEP20 (BSC) |
| **Bitcoin (BTC)** | Bitcoin Network |
| **Ethereum (ETH)** | ERC20 |
| **BNB** | BEP20 (BSC) |
| **Binance Pay** | Binance QR Code |

---

## 🔗 Django Integration

```python
# views.py
from django.shortcuts import redirect
from django.views import View
from binance_and_crypto_payment import CryptoPaymentClient
import time

class CheckoutView(View):
    def post(self, request):
        client = CryptoPaymentClient(
            public_key="YOUR_PUBLIC_KEY",
            secret_key="YOUR_SECRET_KEY"
        )

        response = client.payment(
            invoice_id=f"PYP-{int(time.time())}",
            amount=float(request.POST.get("amount", 10.00)),
            currency="USD",
            items=[{
                "name":  request.POST.get("product", "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": request.build_absolute_uri("/payment/success/"),
                "notify_url":   request.build_absolute_uri("/payment/notify/"),
                "cancel_url":   request.build_absolute_uri("/payment/cancel/"),
            }
        )

        return redirect(response["redirect_to"])
```

```python
# urls.py
from django.urls import path
from .views import CheckoutView

urlpatterns = [
    path("checkout/", CheckoutView.as_view(), name="checkout"),
]
```

---

## 🔗 Flask Integration

```python
# app.py
from flask import Flask, request, redirect
from binance_and_crypto_payment import CryptoPaymentClient
import time

app = Flask(__name__)

client = CryptoPaymentClient(
    public_key="YOUR_PUBLIC_KEY",
    secret_key="YOUR_SECRET_KEY"
)

@app.route("/pay", methods=["POST"])
def pay():
    response = client.payment(
        invoice_id=f"PYP-{int(time.time())}",
        amount=float(request.form["amount"]),
        currency="USD",
        items=[{
            "name":  request.form.get("product", "Order"),
            "qty":   "1",
            "price": request.form["amount"],
        }],
        data={
            "first_name": request.form["first_name"],
            "last_name":  request.form["last_name"],
            "email":      request.form["email"],
            "redirect_url": "https://yoursite.com/payment/success",
            "notify_url":   "https://yoursite.com/payment/notify",
            "cancel_url":   "https://yoursite.com/payment/cancel",
        }
    )
    return redirect(response["redirect_to"])
```

---

## 🔗 FastAPI Integration

```python
# main.py
from fastapi import FastAPI, Form
from fastapi.responses import RedirectResponse
from binance_and_crypto_payment import CryptoPaymentClient
import time

app = FastAPI()

client = CryptoPaymentClient(
    public_key="YOUR_PUBLIC_KEY",
    secret_key="YOUR_SECRET_KEY"
)

@app.post("/pay")
async def pay(
    amount: float = Form(...),
    first_name: str = Form(...),
    last_name: str = Form(...),
    email: str = Form(...),
):
    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": "https://yoursite.com/payment/success",
            "notify_url":   "https://yoursite.com/payment/notify",
            "cancel_url":   "https://yoursite.com/payment/cancel",
        }
    )
    return RedirectResponse(url=response["redirect_to"])
```

---

## 🔔 Handling Webhooks (notify_url)

When a payment is completed, PayerURL sends a `POST` request to your `notify_url`. Here is how to handle it:

```python
# Django webhook handler — views.py
import json
import hmac
import hashlib
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt

@csrf_exempt
def payment_notify(request):
    if request.method != "POST":
        return JsonResponse({"error": "Method not allowed"}, status=405)

    data = request.POST  # or json.loads(request.body) if JSON

    order_id    = data.get("order_id")
    status_code = data.get("status_code")
    txn_id      = data.get("transaction_id")

    if str(status_code) == "200":
        # Payment confirmed — update your order status here
        # Order.objects.filter(id=order_id).update(status="paid")
        return JsonResponse({"status": 2040, "message": "Order updated"})

    return JsonResponse({"status": 2050, "message": "Pending"})
```

```python
# Flask webhook handler
from flask import Flask, request, jsonify

@app.route("/payment/notify", methods=["POST"])
def payment_notify():
    data        = request.form
    order_id    = data.get("order_id")
    status_code = data.get("status_code")
    txn_id      = data.get("transaction_id")

    if str(status_code) == "200":
        # Payment confirmed — update your database here
        return jsonify({"status": 2040, "message": "Order updated"})

    return jsonify({"status": 2050, "message": "Pending"})
```

### Webhook Payload Fields

| Field | Description |
|---|---|
| `order_id` | Your original invoice ID |
| `transaction_id` | Blockchain transaction hash |
| `status_code` | `200` = completed, `20000` = cancelled |
| `confirm_rcv_amnt` | Amount received in fiat |
| `confirm_rcv_amnt_curr` | Fiat currency (e.g. USD) |
| `coin_rcv_amnt` | Amount received in crypto |
| `coin_rcv_amnt_curr` | Crypto symbol (e.g. USDT) |
| `txn_time` | Transaction timestamp |

---

## 📲 How the Binance QR Payment Works

1. Your app calls the API and gets a **payment URL**
2. Customer is redirected to a secure checkout page
3. Customer **scans the QR code** with their Binance app
4. Payment is confirmed and funds land **directly in your wallet**
5. Your `notify_url` receives a webhook with the order status

No bank accounts. No intermediaries. No waiting.

---

## 🛡️ Security & Privacy

- ✅ Payments go directly to **your** wallet — PayerURL never holds your funds
- ✅ No mandatory KYC for basic accounts
- ✅ HMAC-SHA256 signature verification on all API calls
- ✅ MIT licensed — fully open source, audit it yourself
- ✅ No personal identity verification required to get started

---

## 🌍 Supported Fiat Currencies (169+)

USD, EUR, GBP, CAD, AUD, JPY, SGD, AED, INR, BRL, MXN, NGN, PKR, BDT, and 150+ more.

All fiat amounts are automatically converted to the equivalent crypto amount at live market rates.

---

## 📊 Full Payment Flow

```
Your App  ──►  PayerURL API  ──►  Checkout Page  ──►  Customer Pays
                                                              │
Your Wallet  ◄──  Funds (instant)  ◄──  Blockchain Confirmed ┘
                                                              │
              Your notify_url  ◄──  Webhook (status update) ─┘
```

---

## 🆚 Compared to Other Solutions

| | **PayerURL (This Package)** | Stripe / PayPal | Coinbase Commerce |
|---|---|---|---|
| No merchant account | ✅ | ❌ | ✅ |
| Direct to your wallet | ✅ | ❌ | Partial |
| No KYC required | ✅ (Basic) | ❌ | ❌ |
| Binance QR support | ✅ | ❌ | ❌ |
| Python SDK | ✅ | ✅ | ✅ |
| Django / Flask / FastAPI | ✅ | ✅ | ❌ |
| 169+ fiat currencies | ✅ | Partial | ❌ |
| Zero platform fees | ✅ | ❌ | ❌ |
| Webhook support | ✅ | ✅ | ✅ |

---

## ❓ FAQ

**Do I need a Binance account?**
Yes, to accept Binance QR payments. For USDT/BTC/ETH/USDC, you only need the corresponding wallet address configured in your PayerURL dashboard.

**Is there a transaction fee?**
No platform fees from PayerURL. Standard blockchain network fees may apply depending on the coin and network.

**Can I use this without KYC?**
Yes. Basic accounts can receive and withdraw crypto without mandatory identity verification.

**What should my notify_url return?**
Return a JSON response with `{"status": 2040, "message": "Order updated"}` on success. PayerURL expects a `200 HTTP` status code.

**Does this work with Django REST Framework / FastAPI?**
Yes — it is a pure Python client that works with any Python web framework.

**What Python versions are supported?**
Python 3.8 and above (3.8, 3.9, 3.10, 3.11, 3.12, 3.13).

---

## 📬 Support

| Channel | Link |
|---|---|
| 💬 Telegram | [t.me/Payerurl](https://t.me/Payerurl) |
| 🌐 Website | [payerurl.com](https://payerurl.com) |
| 📊 Dashboard | [dash.payerurl.com](https://dash.payerurl.com) |
| 🔴 Live Demo | [python.payerurl.com](https://python.payerurl.com) |

---

## 📄 License

MIT License — free for personal and commercial use.

---

## 🔑 Keywords

`crypto` `bitcoin` `ethereum` `binance` `coinbase` `usdt` `usdc` `bnb` `tron` `payment` `payment-gateway` `crypto-payment-gateway` `cryptocurrency-payment` `bitcoin-payment` `binance-pay` `binance-api` `accept-crypto` `crypto-checkout` `django-payment` `flask-payment` `fastapi-payment` `usdt-trc20` `usdt-erc20` `no-kyc-payment` `instant-settlement` `crypto-webhook` `direct-to-wallet` `credit-card-to-crypto`
