🛹Getting Started
Learn how to setup your API to use PayPI
Interact with PayPI using our SDKs:
Get started creating an API or check out some of our example implementations:
Go Yoda (A text to Yoda speak API in Go)
Express Yoda (A text to Yoda speak API in NodeJS)
EmailVerify (Email verification API from PayPI)
1. Setup Partner Account
To setup a PayPI team to become a partner, switch to that team and click "Sell on PayPI", this will allow you access to the API Manager via the marketplace icon in the main menu, where you can start creating and managing your APIs.

2. Create an API
Create an API on the PayPI website and keep note of your API Secret (you'll use this to authenticate your API) and your Share URL (your users need this to subscribe to your API).
Create a charge
To accept payments you need to decide what to charge your users. Charges are created in the “charges” section of your API dashboard, they state what you are going to be charging your users for and how much.
We recommend the following when creating charges:
3. Setup your API Application
Install PayPI's library, where you plan to do your authentication.
go get -u github.com/paypi/paypi-go
Setup API
Import the PayPI library and set your API Secret.
import (
"http"
"github.com/paypi/paypi-go/paypi"
)
paypi.Key = "<API_SECRET_KEY>"
Authenticate users
To take payments, you must first check that the API token they have given you is valid.
user, err := paypi.Authenticate("<Subscriber secret>")
if err != nil {
http.Error(w, "User token is unauthorized", http.StatusUnauthorized)
return
}
If this method returns without error you can continue processing the request. If it fails you should immediately return an unauthorised response from your API.
4. Make Charges
user.MakeCharge
is used to charge users on the platform. When user.MakeCharge
is called the user is charged for their usage on your platform. This should be done at the end of your request, when you are sure that their request is going to be fulfilled successfully.
Static Charges
Static charges need only provide the charge identifier
user, _ := paypi.Authenticate("<USER_TOKEN>")
charge, err := user.MakeCharge(paypi.MakeChargeInput{
ChargeIdentifier: "<CHARGE_IDENTIFIER>",
})
Dynamic Charges
If a charge is dynamic, you must provide the number of units used. This is usually representative of seconds of processing time, or MB of data processed. This unit is multiplied by the price set for the dynamic charge to calculate the total cost to the user.
user, _ := paypi.Authenticate("<USER_TOKEN>")
charge, err := user.MakeCharge(paypi.MakeChargeInput{
ChargeIdentifier: "<CHARGE_IDENTIFIER>",
UnitsUsed: 5,
})
Example Usage
package main
import (
"http"
"github.com/paypi/paypi-go/paypi"
)
// Set the API secret key on initialising your application
paypi.Key = "<API_SECRET_KEY>"
func handleRequest(w http.ResponseWriter, r *http.Request) {
// Check if a user's token is valid, this token usually comes from the
// Authorization header, but can be given in any way you choose.
user, err := paypi.Authenticate(r.Header.Get("Authorization"))
if err != nil {
http.Error(w, "User token is unauthorized", http.StatusUnauthorized)
return
}
// Do some processing, fetch the response etc...
// If request was successful, make a static charge
charge, err := user.MakeCharge(paypi.MakeChargeInput{
ChargeIdentifier: "<STATIC_CHARGE_IDENTIFIER>",
})
// Make a dynamic charge based on processing
charge, err = user.MakeCharge(paypi.MakeChargeInput{
ChargeIdentifier: "<DYNAMIC_CHARGE_IDENTIFIER>",
UnitsUsed: 2.34,
})
fmt.Fprintf(w, "Request Successful")
}
5. Share your API
Inform your users they can pay with PayPI by redirecting them to the Share URL link for your API.
Last updated
Was this helpful?