Accepting Payments via Payment Pages

Learn when and how to accept multiple payments using reusable payment page links

Payment pages provide a reusable way to collect payments through secure, hosted payment pages. Unlike one-time payment requests, payment pages can be used indefinitely to accept multiple payments from multiple customers. Create a payment page once and share it on your website, in emails, or via any communication channel—customers can use the same link repeatedly to make payments.

Prerequisites

Before creating payment pages, it's helpful to learn about the following topics.

When to Use Payment Pages

Use payment pages when you need a permanent, reusable payment link that can accept multiple payments over time. Payment pages remain active indefinitely until you deactivate them, making them ideal for ongoing payment collection scenarios.

By using payment pages, PCI compliance and sensitive payment data handling are managed automatically. The hosted page ensures secure collection of card and bank account details in a compliant environment—removing that responsibility from your application.

Common use cases

• Product Sales: Create a payment page for each product or service
• Donation Pages: Accept ongoing donations with a single reusable link
• Membership Fees: Collect recurring membership or subscription payments
• Service Payments: Create permanent payment links for specific services
• Website Integration: Embed payment links directly on your website
• QR Codes: Generate QR codes that link to your payment page

Creating a Payment Page

Creating a payment page is a two-step process: create a payment link with the reusable type, then share or embed the returned URL.

import payload
pl = payload.Session('secret_key_3bW9...', api_version='v2')
 
# Create a reusable payment page
payment_link = pl.PaymentLink.create(
    type='reusable',
    description='Product Payment',
    amount=100.00,
    biller={'account_id': 'acct_receiver123'}
)
 
# Share the URL on your website or in communications
print(f"Payment page: {payment_link.url}")

This example creates a payment link with:

1. type='reusable' tells Payload to generate a multi-use payment link
2. description provides context about what the customer is paying for
3. amount sets the payment amount
4. biller.account_id specifies the account that will receive payments

The response includes a url field that contains the secure payment page URL. Share this URL on your website, in communications, or embed it in your application.

Configuring Payment Options

Payment pages support checkout configuration options, allowing you to control payment methods, fees, custom fields, and UI behavior.

Payment Methods

Control which payment types are available on your payment page:

import payload
pl = payload.Session('secret_key_3bW9...', api_version='v2')
 
# Create a payment page with specific payment methods
payment_link = pl.PaymentLink.create(
    type='reusable',
    description='Product Payment',
    amount=100.00,
    biller={'account_id': 'acct_receiver123'},
    checkout_options={
        'card_payments': True,
        'bank_account_payments': True,
        'enable_mobile_wallets': True
    }
)
 
print(f"Payment page: {payment_link.url}")

This configuration:

• Enables card payments (Visa, Mastercard, American Express, Discover)
• Enables bank account payments (bank transfer)
• Enables Apple Pay and Google Pay for customers on compatible devices

Editable Amount

Allow customers to change the payment amount, useful for donations or variable payments:

import payload
 
pl = payload.Session("secret_key_3bW9...", api_version="v2")
 
# Create a payment page with editable amount
payment_link = pl.PaymentLink.create(
    type="reusable",
    description="Donation",
    amount=25.00,
    biller={"account_id": "acct_receiver123"},
    field_options={"amount_field": "editable"},
)
 
print(f"Payment page: {payment_link.url}")

This configuration:

• Displays the initial amount as $25
• Allows customers to change the amount to any value they choose
• Perfect for donation pages, tips, or pay-what-you-want scenarios

Custom Fields

Collect additional information from customers during checkout:

import payload
pl = payload.Session('secret_key_3bW9...', api_version='v2')
 
# Create a payment page with custom fields
payment_link = pl.PaymentLink.create(
    type='reusable',
    description='Product Order',
    amount=100.00,
    biller={'account_id': 'acct_receiver123'},
    field_options={
        'custom_fields': [{
            'section': 'Order Details',
            'fields': [
                {
                    'title': 'Product SKU',
                    'name': 'product_sku',
                    'type': 'text',
                    'optional': False
                },
                {
                    'title': 'Quantity',
                    'name': 'quantity',
                    'type': 'text',
                    'value': '1',
                    'optional': True
                }
            ]
        }]
    }
)
 
print(f"Payment page: {payment_link.url}")

This configuration:

• Adds custom form fields grouped by section
• Collects product SKU and quantity information
• Field values are stored in the transaction attrs object
• Supports text, email, phone, date, and other field types

Embedding Payment Pages

Payment pages can be shared as links or embedded directly in your website using iframes or buttons.

Link or Embed Options

Share your payment page URL directly or embed it in your website:

<!DOCTYPE html>
<html>
<head>
  <title>Payment Page</title>
</head>
<body>
  <h1>Make a Payment</h1>
 
  <!-- Link to payment page -->
  <!-- <a href="https://pay.payload.com/abc123" class="payment-button">
    Pay Now
  </a> -->
 
  <!-- Or embed in iframe -->
  <!-- <iframe
    src="https://pay.payload.com/abc123"
    width="100%"
    height="600"
    frameborder="0">
  </iframe> -->
  <script src="embed.js"></script>
</body>
</html>

// This example is static markup-only. Keep a same-basename JS file
// so frontend example traversal can enforce consistent html/js pairing.

Direct Link: Share the payment page URL anywhere - emails, SMS, social media, QR codes

Iframe Embed: Embed the payment page directly in your website for a seamless experience

Button Link: Add payment buttons throughout your website that link to the payment page

Tracking Payment Activity

Payment pages can accept multiple payments over time. Monitor activity through webhooks and API queries.

Webhook Events

Subscribe to the processed webhook trigger to track all successful payments through your payment page. Configure a webhook with:

• trigger: processed - Monitors successful payment completion
• reference_object: transaction - Specifies the object type being monitored
• url: Your endpoint URL to receive webhook notifications

Example webhook handler:

from flask import Flask, request
 
app = Flask(__name__)
 
@app.route("/webhooks/payload", methods=["POST"])
def handle_webhook():
    webhook = request.json
 
    if webhook["trigger"] == "processed" and webhook["triggered_on"]["type"] == "payment":
        transaction = webhook["triggered_on"]
        payment_link_id = transaction["payment_link_id"]
 
        print(f"Payment received via page: {payment_link_id}")
        print(f"Transaction: {transaction['id']}")
        print(f"Amount: {transaction['amount']}")
        # Update your database
        # Send confirmation email
 
    return "OK", 200

Query Payment Activity

List all payments made through a payment page:

import payload
 
pl = payload.Session("secret_key_3bW9...", api_version="v2")
 
# List all payments made through this payment page
payment_link_id = "pay_abc123def456"
 
transactions = pl.Transaction.filter_by(payment_link_id=payment_link_id).all()
 
print(f"Total payments: {len(transactions)}")
 
# Calculate total revenue
total_amount = sum(txn.amount for txn in transactions)
print(f"Total revenue: ${total_amount}")
 
# List recent payments
for txn in transactions:
    print(f"{txn.created_at}: ${txn.amount} - {txn.status}")

This allows you to:

• List all transactions made through the page
• Monitor total payment volume
• Track customer activity
• Filter payments by date, amount, or status

Managing Payment Pages

Deactivating a Payment Page

When you no longer want to accept payments through a payment page, deactivate it:

import payload
pl = payload.Session('secret_key_3bW9...', api_version='v2')
 
# Deactivate a payment page
payment_link_id = 'pay_abc123def456'
 
payment_link = pl.PaymentLink.get(payment_link_id)
payment_link.update(status='inactive')
 
print(f"Payment page deactivated: {payment_link.status}")

Deactivating a payment page:

• Immediately stops accepting new payments
• Returns an error if customers try to use the link
• Does not affect past transactions
• Can be reactivated later if needed

Schema Reference

The following fields are available when configuring payment pages:

Payment Link Configuration

Configuration options passed when creating the payment page. For complete API reference, see Payment Links API Reference.

Next Steps

Enhance your payment page implementation

Send Payment Receipts

Configure receipts to automatically send confirmation emails with custom fields and transaction details.

Handle Refunds

Process refunds and voids for cancellations and returns after payments complete.

Monitor Payment Events

Subscribe to webhook notifications to track payment status and automate order fulfillment.

Related articles

• Payment Requests - One-time payment links
• Checkout Plugin - Embedded checkout form alternative
• Payment Links API Reference
• Transactions API Reference