Claude Cursor Skill

paypal-integration

Integrate PayPal payment processing with support for express checkout, subscriptions, and refund management. Use when implementing PayPal payments, processing online transactions, or building e-commerce checkout flows.

LLM Mart · 0 points · 19 views 0 listing impressions 0 install-command copies
Download wshobson-agents-plugins_payment-processing_skills_paypal-integration-554237f.zip · 4 KB

Install

skills CLI npx skills add https://github.com/wshobson/agents/tree/main/plugins/payment-processing/skills/paypal-integration
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install wshobson-agents@llmmart
Git git clone https://github.com/wshobson/agents.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole wshobson/agents collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

PayPal Integration

Master PayPal payment integration including Express Checkout, IPN handling, recurring billing, and refund workflows.

When to Use This Skill

  • Integrating PayPal as a payment option
  • Implementing express checkout flows
  • Setting up recurring billing with PayPal
  • Processing refunds and payment disputes
  • Handling PayPal webhooks (IPN)
  • Supporting international payments
  • Implementing PayPal subscriptions

Core Concepts

1. Payment Products

PayPal Checkout

  • One-time payments
  • Express checkout experience
  • Guest and PayPal account payments

PayPal Subscriptions

  • Recurring billing
  • Subscription plans
  • Automatic renewals

PayPal Payouts

  • Send money to multiple recipients
  • Marketplace and platform payments

2. Integration Methods

Client-Side (JavaScript SDK)

  • Smart Payment Buttons
  • Hosted payment flow
  • Minimal backend code

Server-Side (REST API)

  • Full control over payment flow
  • Custom checkout UI
  • Advanced features

3. IPN (Instant Payment Notification)

  • Webhook-like payment notifications
  • Asynchronous payment updates
  • Verification required

Quick Start

// Frontend - PayPal Smart Buttons
<div id="paypal-button-container"></div>

<script src="https://www.paypal.com/sdk/js?client-id=YOUR_CLIENT_ID&currency=USD"></script>
<script>
  paypal.Buttons({
    createOrder: function(data, actions) {
      return actions.order.create({
        purchase_units: [{
          amount: {
            value: '25.00'
          }
        }]
      });
    },
    onApprove: function(data, actions) {
      return actions.order.capture().then(function(details) {
        // Payment successful
        console.log('Transaction completed by ' + details.payer.name.given_name);

        // Send to backend for verification
        fetch('/api/paypal/capture', {
          method: 'POST',
          headers: {'Content-Type': 'application/json'},
          body: JSON.stringify({orderID: data.orderID})
        });
      });
    }
  }).render('#paypal-button-container');
</script>
# Backend - Verify and capture order
from paypalrestsdk import Payment
import paypalrestsdk

paypalrestsdk.configure({
    "mode": "sandbox",  # or "live"
    "client_id": "YOUR_CLIENT_ID",
    "client_secret": "YOUR_CLIENT_SECRET"
})

def capture_paypal_order(order_id):
    """Capture a PayPal order."""
    payment = Payment.find(order_id)

    if payment.execute({"payer_id": payment.payer.payer_info.payer_id}):
        # Payment successful
        return {
            'status': 'success',
            'transaction_id': payment.id,
            'amount': payment.transactions[0].amount.total
        }
    else:
        # Payment failed
        return {
            'status': 'failed',
            'error': payment.error
        }

Detailed patterns and worked examples

Detailed pattern documentation lives in references/details.md. Read that file when the navigation tier above is insufficient.

Testing

# Use sandbox credentials
SANDBOX_CLIENT_ID = "..."
SANDBOX_SECRET = "..."

# Test accounts
# Create test buyer and seller accounts at developer.paypal.com

def test_payment_flow():
    """Test complete payment flow."""
    client = PayPalClient(SANDBOX_CLIENT_ID, SANDBOX_SECRET, mode='sandbox')

    # Create order
    order = client.create_order(10.00)
    assert 'id' in order

    # Get approval URL
    approval_url = next((link['href'] for link in order['links'] if link['rel'] == 'approve'), None)
    assert approval_url is not None

    # After approval (manual step with test account)
    # Capture order
    # captured = client.capture_order(order['id'])
    # assert captured['status'] == 'COMPLETED'
Files (agents)
  • references
    • details.md 8.4 KB
      Loading…
  • SKILL.md 3.9 KB
    ---
    name: paypal-integration
    description: Integrate PayPal payment processing with support for express checkout, subscriptions, and refund management. Use when implementing PayPal payments, processing online transactions, or building e-commerce checkout flows.
    ---
    
    # PayPal Integration
    
    Master PayPal payment integration including Express Checkout, IPN handling, recurring billing, and refund workflows.
    
    ## When to Use This Skill
    
    - Integrating PayPal as a payment option
    - Implementing express checkout flows
    - Setting up recurring billing with PayPal
    - Processing refunds and payment disputes
    - Handling PayPal webhooks (IPN)
    - Supporting international payments
    - Implementing PayPal subscriptions
    
    ## Core Concepts
    
    ### 1. Payment Products
    
    **PayPal Checkout**
    
    - One-time payments
    - Express checkout experience
    - Guest and PayPal account payments
    
    **PayPal Subscriptions**
    
    - Recurring billing
    - Subscription plans
    - Automatic renewals
    
    **PayPal Payouts**
    
    - Send money to multiple recipients
    - Marketplace and platform payments
    
    ### 2. Integration Methods
    
    **Client-Side (JavaScript SDK)**
    
    - Smart Payment Buttons
    - Hosted payment flow
    - Minimal backend code
    
    **Server-Side (REST API)**
    
    - Full control over payment flow
    - Custom checkout UI
    - Advanced features
    
    ### 3. IPN (Instant Payment Notification)
    
    - Webhook-like payment notifications
    - Asynchronous payment updates
    - Verification required
    
    ## Quick Start
    
    ```javascript
    // Frontend - PayPal Smart Buttons
    <div id="paypal-button-container"></div>
    
    <script src="https://www.paypal.com/sdk/js?client-id=YOUR_CLIENT_ID&currency=USD"></script>
    <script>
      paypal.Buttons({
        createOrder: function(data, actions) {
          return actions.order.create({
            purchase_units: [{
              amount: {
                value: '25.00'
              }
            }]
          });
        },
        onApprove: function(data, actions) {
          return actions.order.capture().then(function(details) {
            // Payment successful
            console.log('Transaction completed by ' + details.payer.name.given_name);
    
            // Send to backend for verification
            fetch('/api/paypal/capture', {
              method: 'POST',
              headers: {'Content-Type': 'application/json'},
              body: JSON.stringify({orderID: data.orderID})
            });
          });
        }
      }).render('#paypal-button-container');
    </script>
    ```
    
    ```python
    # Backend - Verify and capture order
    from paypalrestsdk import Payment
    import paypalrestsdk
    
    paypalrestsdk.configure({
        "mode": "sandbox",  # or "live"
        "client_id": "YOUR_CLIENT_ID",
        "client_secret": "YOUR_CLIENT_SECRET"
    })
    
    def capture_paypal_order(order_id):
        """Capture a PayPal order."""
        payment = Payment.find(order_id)
    
        if payment.execute({"payer_id": payment.payer.payer_info.payer_id}):
            # Payment successful
            return {
                'status': 'success',
                'transaction_id': payment.id,
                'amount': payment.transactions[0].amount.total
            }
        else:
            # Payment failed
            return {
                'status': 'failed',
                'error': payment.error
            }
    ```
    
    ## Detailed patterns and worked examples
    
    Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient.
    
    ## Testing
    
    ```python
    # Use sandbox credentials
    SANDBOX_CLIENT_ID = "..."
    SANDBOX_SECRET = "..."
    
    # Test accounts
    # Create test buyer and seller accounts at developer.paypal.com
    
    def test_payment_flow():
        """Test complete payment flow."""
        client = PayPalClient(SANDBOX_CLIENT_ID, SANDBOX_SECRET, mode='sandbox')
    
        # Create order
        order = client.create_order(10.00)
        assert 'id' in order
    
        # Get approval URL
        approval_url = next((link['href'] for link in order['links'] if link['rel'] == 'approve'), None)
        assert approval_url is not None
    
        # After approval (manual step with test account)
        # Capture order
        # captured = client.capture_order(order['id'])
        # assert captured['status'] == 'COMPLETED'
    ```
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.