Using PayPal Standard IPN¶

1. Edit settings.py and add paypal.standard.ipn to your INSTALLED_APPS and PAYPAL_RECEIVER_EMAIL:

   settings.py:

   #...
   
   INSTALLED_APPS = [
       #...
       'paypal.standard.ipn',
       #...
   ]
   
   #...
   PAYPAL_RECEIVER_EMAIL = "yourpaypalemail@example.com"
   

   For installations on which you want to use the sandbox, set PAYPAL_TEST to True. Ensure PAYPAL_RECEIVER_EMAIL is set to your sandbox account email too.

2. Update the database

3. Create an instance of the PayPalPaymentsForm in the view where you would like to collect money. Call render on the instance in your template to write out the HTML.

   views.py:

   from paypal.standard.forms import PayPalPaymentsForm
   
   def view_that_asks_for_money(request):
   
       # What you want the button to do.
       paypal_dict = {
           "business": settings.PAYPAL_RECEIVER_EMAIL,
           "amount": "10000000.00",
           "item_name": "name of the item",
           "invoice": "unique-invoice-id",
           "notify_url": "https://www.example.com" + reverse('paypal-ipn'),
           "return_url": "https://www.example.com/your-return-location/",
           "cancel_return": "https://www.example.com/your-cancel-location/",
   
       }
   
       # Create the instance.
       form = PayPalPaymentsForm(initial=paypal_dict)
       context = {"form": form}
       return render_to_response("payment.html", context)
   

   For a full list of variables that can be used in paypal_dict, see PayPal HTML variables documentation”

   payment.html:

   ...
   <h1>Show me the money!</h1>
   <!-- writes out the form tag automatically -->
   {{ form.render }}
   

4. When someone uses this button to buy something PayPal makes a HTTP POST to your “notify_url”. PayPal calls this Instant Payment Notification (IPN). The view paypal.standard.ipn.views.ipn handles IPN processing. To set the correct notify_url add the following to your urls.py:

   urlpatterns = patterns('',
       (r'^something/paypal/', include('paypal.standard.ipn.urls')),
   )
   

5. Whenever an IPN is processed a signal will be sent with the result of the transaction. Connect the signals to actions to perform the needed operations when a successful payment is received.

   The IPN signals should be imported from paypal.standard.ipn.signals.

   There are four signals for basic transactions:

   • payment_was_successful
   • payment_was_flagged
   • payment_was_refunded
   • payment_was_reversed

   And four signals for subscriptions:

   • subscription_cancel - Sent when a subscription is cancelled.
   • subscription_eot - Sent when a subscription expires.
   • subscription_modify - Sent when a subscription is modified.
   • subscription_signup - Sent when a subscription is created.

   Several more exist for recurring payments:

   • recurring_create - Sent when a recurring payment is created.
   • recurring_payment - Sent when a payment is received from a recurring payment.
   • recurring_cancel - Sent when a recurring payment is cancelled.
   • recurring_suspend - Sent when a recurring payment is suspended.
   • recurring_reactivate - Sent when a recurring payment is reactivated.

   Connect to these signals and update your data accordingly. Django Signals Documentation.

   models.py:

   from paypal.standard.ipn.signals import payment_was_successful
   
   def show_me_the_money(sender, **kwargs):
       ipn_obj = sender
       # You need to check 'payment_status' of the IPN
   
       if ipn_obj.payment_status == "Completed":
           # Undertake some action depending upon `ipn_obj`.
           if ipn_obj.custom == "Upgrade all users!":
               Users.objects.update(paid=True)
       else:
           #...
   
   payment_was_successful.connect(show_me_the_money)
   

   The data variables that are return on the IPN object are documented here:

   https://developer.paypal.com/webapps/developer/docs/classic/ipn/integration-guide/IPNandPDTVariables/

   You need to pay particular attention to payment_status.

6. You will also need to implement the return_url and cancel_return views to handle someone returning from PayPal. Note that these views need @csrf_exempt applied to them, because PayPal will POST to them, so they should be custom views that don’t need to handle POSTs otherwise.

   For ‘return_url’ you need to cope with the possibility that the IPN has not yet been received and handled by the IPN listener you implemented (which can happen rarely), or that there was some kind of error with the IPN.

Using PayPal Standard PDT¶

Paypal Payment Data Transfer (PDT) allows you to display transaction details to a customer immediately on return to your site unlike PayPal IPN which may take some seconds. You will need to enable PDT in your PayPal account to use it.

However, PDT also has the disadvantage that you only get one chance to handle the notification - if there is a connection error for your user, the notification will never arrive at your site. For this reason, using PDT with django-paypal is not as well supported as IPN.

To use PDT:

1. Edit settings.py and add paypal.standard.pdt to your INSTALLED_APPS. Also set PAYPAL_IDENTITY_TOKEN - you can find the correct value of this setting from the PayPal website:

   settings.py:

   #...
   INSTALLED_APPS = [
       #...
       'paypal.standard.pdt',
       #...
   ]
   
   #...
   
   PAYPAL_IDENTITY_TOKEN = "xxx"
   

   For installations on which you want to use the sandbox, set PAYPAL_TEST to True. Ensure PAYPAL_RECEIVER_EMAIL is set to your sandbox account email too.

2. Update the database

3. Create a view that uses PayPalPaymentsForm just like in Using PayPal Standard IPN.

4. After someone uses this button to buy something PayPal will return the user to your site at your return_url with some extra GET parameters.

   The view paypal.standard.pdt.views.pdt handles PDT processing and renders a simple template. It can be used as follows:

   Add the following to your urls.py:

   ...
   urlpatterns = patterns('',
       (r'^paypal/pdt/', include('paypal.standard.pdt.urls')),
       ...
   )
   

   Then specify the return_url to use this URL.

   More than likely, however, you will want to write a custom view that calls paypal.standard.pdt.views.process_pdt. This function returns a tuple containing (PDT object, flag), where the flag is True if verification failed.

Using PayPal Standard with Subscriptions¶

For subscription actions, you’ll need to add a parameter to tell it to use the subscription buttons and the command, plus any subscription-specific settings:

views.py:

 paypal_dict = {
    "cmd": "_xclick-subscriptions",
    "business": "your_account@paypal",
    "a3": "9.99",                      # monthly price
    "p3": 1,                           # duration of each unit (depends on unit)
    "t3": "M",                         # duration unit ("M for Month")
    "src": "1",                        # make payments recur
    "sra": "1",                        # reattempt payment on payment error
    "no_note": "1",                    # remove extra notes (optional)
    "item_name": "my cool subscription",
    "notify_url": "http://www.example.com/your-ipn-location/",
    "return_url": "http://www.example.com/your-return-location/",
    "cancel_return": "http://www.example.com/your-cancel-location/",
}

# Create the instance.
form = PayPalPaymentsForm(initial=paypal_dict, button_type="subscribe")

# Output the button.
form.render()

Using PayPal Standard with Encrypted Buttons¶

Use this method to encrypt your button so sneaky gits don’t try to hack it. Thanks to Jon Atkinson for the tutorial.

1. Encrypted buttons require the M2Crypto library:

   pip install M2Crypto
   

2. Encrypted buttons require certificates. Create a private key:

   openssl genrsa -out paypal.pem 1024
   

3. Create a public key:

   openssl req -new -key paypal.pem -x509 -days 365 -out pubpaypal.pem
   

4. Upload your public key to the paypal website (sandbox or live).

   https://www.paypal.com/us/cgi-bin/webscr?cmd=_profile-website-cert

   https://www.sandbox.paypal.com/us/cgi-bin/webscr?cmd=_profile-website-cert

5. Copy your cert id - you’ll need it in two steps. It’s on the screen where you uploaded your public key.

6. Download PayPal’s public certificate - it’s also on that screen.

7. Edit your settings.py to include cert information:

   PAYPAL_PRIVATE_CERT = '/path/to/paypal.pem'
   PAYPAL_PUBLIC_CERT = '/path/to/pubpaypal.pem'
   PAYPAL_CERT = '/path/to/paypal_cert.pem'
   PAYPAL_CERT_ID = 'get-from-paypal-website'
   

8. Swap out your unencrypted button for a PayPalEncryptedPaymentsForm:

   In views.py:

   from paypal.standard.forms import PayPalEncryptedPaymentsForm
   
   def view_that_asks_for_money(request):
       ...
       # Create the instance.
       form = PayPalPaymentsForm(initial=paypal_dict)
       # Works just like before!
       form.render()