import requests

headers = {"X-Merchant-Key": "mk_live_YOUR_KEY"}
payload = {
    "amount": 0.50,
    "billing_mode": "per_use",
    "content_id": "inference_v1"
}

r = requests.post(
    "https://payments.up2.cash/api/merchant/create-invoice",
    json=payload, headers=headers
)
invoice_id = r.json()["invoice_id"]
print(invoice_id)  # e.g. "3e7c-a9f2-..."

pay_r = requests.post(
    "https://payments.up2.cash/api/agent/pay-invoice",
    json={
        "invoice_id": invoice_id,
        "api_key": "ak_live_YOUR_WALLET_KEY"
    }
)
print(pay_r.json())
# {
#   "status": "success",
#   "paid_via": "balance",
#   "deducted": 0.50,
#   "remaining_balance": 4.50
# }

verify_r = requests.get(
    f"https://payments.up2.cash/api/check-status/{invoice_id}"
)
data = verify_r.json()
if data["status"] == "success":
    print("✅ Payment verified — serve the content")
else:
    print("❌ Not paid — block access")

{
  "invoice_id": "3e7c-a9f2-...",
  "amount": 0.50,
  "billing_mode": "per_use",
  "payment_url": "https://payments.up2.cash/checkout?q=...",
  "merchant_id": "upsqrd_live_..."
}

{
  "status": "success",
  "amount": 0.50,
  "currency": "usd",
  "merchant_acct": "upsqrd_live_..."
}

{
  "status": "error",
  "detail": "Receipt already used. Replay verification denied."
}

import requests
from fastapi import FastAPI, Header, HTTPException
from fastapi.responses import JSONResponse

app = FastAPI()

UP2_MERCHANT_KEY = "mk_live_YOUR_KEY"
UP2_API = "https://payments.up2.cash"
PRICE_USD = 0.50

def create_invoice(content_id: str):
    r = requests.post(
        f"{UP2_API}/api/merchant/create-invoice",
        json={"amount": PRICE_USD, "content_id": content_id},
        headers={"X-Merchant-Key": UP2_MERCHANT_KEY}
    )
    return r.json()

def verify_payment(invoice_id: str) -> bool:
    r = requests.get(f"{UP2_API}/api/check-status/{invoice_id}")
    return r.json().get("status") == "success"

@app.post("/api/my-endpoint")
async def my_gated_endpoint(
    x_payment_token: str = Header(None, alias="X-Payment-Token")
):
    # 1. Check for proof of payment
    if x_payment_token and verify_payment(x_payment_token):
        return {"result": "your gated content here"}

    # 2. No payment — create invoice and return 402
    invoice = create_invoice("my-endpoint")
    return JSONResponse(
        status_code=402,
        content={
            "error": "Payment Required",
            "invoice_id": invoice["invoice_id"],
            "amount": PRICE_USD,
            "pay_url": invoice["payment_url"]
        }
    )

{
  "status": "success",
  "receipt": "3e7c-a9f2-...",
  "paid_via": "balance",
  "deducted": 0.50,
  "remaining_balance": 4.50
}

{
  "status": "success",
  "receipt": "3e7c-a9f2-...",
  "paid_via": "card",
  "pi_id": "pi_...",
  "remaining_balance": 0
}

import requests

API_KEY = "ak_live_YOUR_KEY"
PAY_ENDPOINT = "https://payments.up2.cash/api/agent/pay-invoice"

# In-memory receipt store: { domain: invoice_id }
_receipt_store = {}

def up2_request(method: str, url: str, **kwargs):
    """
    Drop-in wrapper for requests.get/post that handles UP² paywalls.
    Returns the final response or raises on failure.
    """
    from urllib.parse import urlparse
    domain = urlparse(url).netloc
    headers = kwargs.pop("headers", {})

    # Phase 0: inject known receipt
    if domain in _receipt_store:
        headers["X-Payment-Token"] = _receipt_store[domain]

    # Phase 1: attempt request
    r = requests.request(method, url, headers=headers, **kwargs)

    if r.status_code != 402:
        return r  # 200 or other — not our problem

    # Phase 2: extract invoice
    data = r.json()
    invoice_id = data.get("invoice_id")
    if not invoice_id:
        raise ValueError("402 response missing invoice_id")

    print(f"💸 Paywall detected. Paying invoice {invoice_id}...")

    # Phase 3: pay
    pay_r = requests.post(
        PAY_ENDPOINT,
        json={"invoice_id": invoice_id, "api_key": API_KEY}
    )
    pay_r.raise_for_status()
    receipt = pay_r.json().get("receipt")

    # Cache receipt for this domain
    _receipt_store[domain] = receipt

    # Phase 4: retry with receipt header
    headers["X-Payment-Token"] = receipt
    return requests.request(method, url, headers=headers, **kwargs)


# Example usage:
r = up2_request("POST", "https://someapi.com/api/inference", json={"prompt": "hello"})
print(r.json())

import requests

TARGET = "https://yourapi.com/endpoint"
PAY_ENDPOINT = "https://payments.up2.cash/api/agent/pay-invoice"
WALLET_KEY = "ak_live_YOUR_KEY"

def get_image(prompt: str):
    payload = {"prompt": prompt, "quality": "high"}

    # 1. Initial attempt
    r1 = requests.post(TARGET, json=payload)

    if r1.status_code == 402:
        invoice_id = r1.json()["invoice_id"]

        # 2. Pay invoice
        r2 = requests.post(PAY_ENDPOINT, json={
            "invoice_id": invoice_id,
            "api_key": MY_API_KEY
        })
        r2.raise_for_status()

        # 3. Retry with receipt
        r3 = requests.post(
            TARGET, json=payload,
            headers={"X-Payment-Token": invoice_id}
        )
        return r3.json().get("image_url")

    return r1.json().get("image_url")

print(get_image("a robot paying for things, neon, 8k"))

from fastapi import FastAPI, Header
from fastapi.responses import JSONResponse
import requests

app = FastAPI()
MERCHANT_KEY = "mk_live_YOUR_KEY"
UP2 = "https://payments.up2.cash"

def issue_invoice():
    r = requests.post(f"{UP2}/api/merchant/create-invoice",
        json={"amount": 0.50, "content_id": "endpoint"},
        headers={"X-Merchant-Key": MK})
    return r.json()

def paid(token: str) -> bool:
    if not token: return False
    r = requests.get(f"{UP2}/api/check-status/{token}")
    return r.json().get("status") == "success"

@app.post("/api/endpoint")
async def draw(body: dict, x_payment_token: str = Header(None)):
    if not paid(x_payment_token):
        inv = issue_invoice()
        return JSONResponse(402, {
            "error": "Payment Required",
            "invoice_id": inv["invoice_id"],
            "amount": 0.50
        })
    # Generate and return image...
    return {"success": True, "image_url": "https://..."}