eSparkBiz offers a broad spectrum of software development and owns expertise in Web Development, Mobile App Development, Industry-specific Solutions, Chatbot, IoT, and more.
We serve for better digitization! Our idea of providing industry-specific solutions has extended in helping different domains such as Fintech & Insurance, Healthcare, Education, Real Estate.
Redefine the process of paying, buying & investing! We utilize the latest technologies to help financial companies gain a competitive edge and build sustainable relationships with customers...
eSparkBiz owns expertise in providing innovation in healthcare from mobile apps. We deploy healthcare IT consulting and interactive apps to improve patient care and manage hospital records...
Leverage the benefits of cost-effective real estate and property solutions to streamline smarter collaboration with customers and expand your company’s reach while optimizing the result...
Create custom education solutions to overcome the challenges while learning and help students & educational institutions drive growth, efficiency and high performance...
We are a sure-footed & out-of-the box thinking Tech-organization who believes in rendering class-apart software solutions along with building long-lasting relationships with our clients.
By facilitating online transfers, PayPal allows customers to create their account on the platform, directly linked to their credit card or checking account. Today, we’re going to talk about PayPal Node.js integration in detail.
PayPal allows ease in transactions for all parties involved. It is also one of the most secure payment gateways, and is a popular choice for merchants too.
If you analyze the features of Node.js, then you will know that it supports multiple payment options. So, let’s start the show, right now.!
Key Things For PayPal Recurring Payments API Integration
The Objective Of The Tutorial
Through this blog tutorial, we wish to achieve the following objectives:
Help users develop an account on the app.
Help users create an application using the developer account and find the client ID and secret.
Help node js development firm understand how the process and flow of payment works.
Help users write the backend script to coordinate with the PayPal JavaScript API.
Help users write complex Node Paypal integration codes that ensure acceptance of payments through PayPal.
Prerequisites
The prerequisites of this tutorial involve users understanding the concepts of:
PayPal Account creation
PayPal Node.js and npm
ExpressJS
How Does the Checkout Integration for PayPal Work?
The most effective way for PayPal checkouts to work is client integration. This kind of integration requires no web servers for payment executions. The PayPal checkout button allows a direct payment execution from the browser.
Here’s how PayPal’s checkout integration functions:
The user taps on the button that lets them check out.
The PayPal API ensures that the payment is set up.
This, in turn, ensures the checkout procedure being carried out in the browser.
In order to ensure the PayPal checkout integration, one needs to set up a development environment. Here’s how that is achieved:
Acquire The Code
You need to write a detailed script or code in order to begin the integration. This script will help you with the integration, with the payment set-up, with its execution, and in carrying out a trial run.
<div id="paypal-button"></div>
<script src="https://www.paypalobjects.com/api/checkout.js"></script>
<script>
paypal.Button.render({
// Configure environment
env: 'sandbox',
client: {
sandbox: 'demo_sandbox_client_id',
production: 'demo_production_client_id'
},
// Customize button (optional)
locale: 'en_US',
style: {
size: 'small',
color: 'gold',
shape: 'pill',
},
// Enable Pay Now checkout flow (optional)
commit: true,
// Set up a payment
payment: function(data, actions) {
return actions.payment.create({
transactions: [{
amount: {
total: '0.01',
currency: 'USD'
}
}]
});
},
// Execute the payment
onAuthorize: function(data, actions) {
return actions.payment.execute().then(function() {
// Show a confirmation message to the buyer
window.alert('Thank you for your purchase!');
});
}
}, '#paypal-button');
</script>
Set Up Payment
Here you will be working with the //set up a payment segment of the script. This is when the buyer clicks on the PayPal button.
// Set up a payment
payment: function(data, actions) {
return actions.payment.create({
transactions: [{
amount: {
total: '0.01',
currency: 'USD'
}
}]
});
}
Execute Payment
This step is concerned with the//execute the payment segment of the script. The code can be scripted to show the authorization process and can even be customised to showcase a confirmation message.
// Execute the payment
onAuthorize: function(data, actions)
{
return actions.payment.execute().then(function()
{
// Show a confirmation message to the buyer
window.alert('Thank you for your purchase!');
});
}
Test The Checkout Button
Before you go live, you need to carry out a trial run to find out if the checkout is smoothly managed. Here’s how you can do it:
Running the trial transactions –
Tap the button that leads you to check out.
With the buyer account, log in to transact.
Conclude a trial transaction.
Corroborating the transactions –
The trial transaction that you just ran also needs to be corroborated. This needs to be done from both the buyer’s standpoint and the merchant’s standpoint
Login to sandbox through your merchant account to check whether the fund has been deposited.
Login to sandbox through your buyer’s account to check whether the funds have been deducted.
Once done, you are ready to go live.
Time To Take It Live
Here’s how you can get the checkout gateway launched.
Create an account for business on PayPal
Sign Up on the site.
Select the ‘Business Account’ option and heed the stated instructions.
Update the credentials
Use the credentials to log into the Developer Dashboard.
Click on the Live option on the ‘My Apps & Credentials’ tab.
Click on the ‘Create App’ option in the ‘REST API apps’ segment.
Configure the live app to match that of sandbox app configuration.
Copy the live client ID.
In the //configure environment segment of the code, set the environment to ‘production’ and add the live client ID.
// Configure environment
env: 'production',
client:
{
production: 'LIVE_CLIENT_ID' //Enter your live client ID here
}
Test a live transaction
A live transaction trial is similar to the test conducted on the trial transaction.
Testing the live transaction
Click on the checkout button.
Login to the PayPal window through your real buyer account.
Complete a real transaction.
Verifying the live transaction
You need to verify the transaction from the buyer’s as well as the merchant’s standpoint.
Log in using the PayPal business account and confirm whether the funds have been deposited.
Log in using the real buyer account to check whether the funds are sent.
Steps For PayPal Recurring Payments Integration With Node.js
It is important to understand what PayPal recurring payments API involves and how it can be integrated with Node.js. Here are the steps to help you understand the integration process:
Step 1: The Working of Node.js Paypal Integration
Understanding how PayPal Node.js works is pretty simple once you know the steps involved in the process.
Here’s a breakdown of the process:
The application gives you a glimpse of the products stored within the database.
The application user chooses the product they intend to purchase and makes a payment against the purchase through the PayPal option.
Upon making the payment using PayPal, the user will then be redirected to the URL for payment cancellations or payment success.
On the server end, the server goes on to execute the payment made by performing a check on the status of the payment. A successful payment indicates payment approval.
Step 2: Creating a PayPal Application
In a PayPal Node.js integration, the first thing you need is a PayPal application. This can be created by visiting developer.paypal.com.
Once you have created the PayPal REST API Recurring Payment Integration application, you will be given a client ID and PayPal secret, of which both would be required in the application.
Just follow this guide to create the application:
Log into the PayPal developer account to create a new application.
If you don’t have an account on PayPa, you need to Sign Up and create a new account.
In the Sign Up process, you need to select an individual or business account option.
Now, fill the necessary details for your account and click on the ‘Next’ button.
After completing this step, you will be able to create a PayPal account with ease.
Now, move to the dashboard of your PayPal Developer Account and search for Application under REST API section. You will see something like this:
Now, click on the ‘Create App’ button as shown below:
Give a name for the application, choose the account, and click on the ‘Create App’ button.
It’s now time to get the client ID and the secret click on the created application.
Step 3: PayPal Sandbox Test Account
In order to test the payments, PayPal Recurring Payments APIoffers you a test run called a sandbox. This is so you can test the application once created before going live with it. Here’s how you go about it:
Go to the developer Paypal account to get your test credentials. Once you have it, click on the Accounts segment under the Sandbox dropdown to the left.
You will be able to see the sandbox test account to the right. Click on buyer email and then on Profile to take a look at your profile.
You can check the test balance by clicking on the Funding tab.
Step 4: Creating a MongoDB Collection
We need a database to store all the data in, which is where MongoDB comes in. We will have the three below-mentioned collections :
Users collection: Under this section, we will be storing the information of the users.
Payments collection: This segment will store a user’s payment for later use.
Step 5: Folder Structure & Package.json
Before we begin with a project, let’s find out a little about the project folder structure. It is an important aspect of PayPal API Recurring Payments.
The Paypal NodeJS integration involves three vital folders – utils, views, node_modules.
To install the PayPal Node.js integration, PayPal JavaScript API provides you with the REST API SDK through the below-mentioned command –
npm install paypal-rest-sdk
Step 7: Creating a Node.js Project
We have already created a package.json folder and checked out the folder structure. It’s not time to create the PayPal NodeJS integration application.
We start by creating config.js in the utils folder. This particular file will deal with express- related configuration.
Config.json:
"use_strict";
/*
* Creating Nodejs PayPal Integration application
* @author Shashank Tiwari
*/
const express = require("express");
const path= require('path');
const method=config.prototype;
function config(app){
// Set .html as the default template extension
app.set('view engine', 'ejs');
// Initialize the ejs template engine
app.engine('html', require('ejs').renderFile);
// Tell express where it can find the templates
app.set('views', (__dirname + '/../views'));
// Make the files in the public folder available to the world
app.use(express.static(path.join('publicData')));
}
method.get_config=function(){
return this;
}
module.exports = config;
Create a db.js file inside the utils folder. This file will deal with database connection.
Create another file called helper.js to perform CRUD operations on the database. This file also helps in carrying out PayPal operations such as creating payments and executing them.
Mentioned below are the codes that help with the functions:
isUserExists : function(data, callback){…=>
This function helps check where the users exist in the database.
insertPayment : function(data, callback){…=>
This function allows you to insert payments into the database.
getProductIndo : function(data, callback){…=>
This function fetches product information for you.
getAllProducts : function(data, callback){…=>
This function fetches information on all the products.
payNow : function(data, callback){…=>
This function helps in creating payments.
getResponse : function(data, callback){…=>
This function involves executing payments. It, therefore, needs a create payment response and a payer ID and returns a callback.
executePayement.ejs is to give the users a response when they return from the PayPal site in order to let them know whether the payment was successful or a failed attempt.
A Guide to Express Checkout With Braintree & Node.js
Here’s a guide to Express Checkout wit Braintree and Node.js:
Starting Up
Express Checkout allows a streamlined checkout process, ensuring that your customers remain on your site throughout the payment procedure while reducing the number of steps involved in the checkout process.
This is specifically designed for those merchants who do not have a merchant account to process direct credit card payments.
Within this checkout process, customers can choose the payment mode and the shipping address while using Express Checkout.
Upon receiving authorisation to process the PayPal transaction, the buyers are brought back to your site to finalise the order.
The Braintree SDK offers an easy checkout experience to your customers through a simple developer integration:
The client SDK that helps in collecting payment details
The server SDK that helps in managing every PayPal request
Setting Up The Client
Braintree’s JavaScript SDK allows you to accept PayPal payments with ease. This involves varied components, of which you can select the ones that you need. Loading of the SDK
The JavaScript SDK components can be loaded directly from the server.
The JavaScript SDK requires server-generated client token.
paypal.Button.render({
braintree: braintree,
client: {
production: 'CLIENT_TOKEN_FROM_SERVER',
sandbox: 'CLIENT_TOKEN_FROM_SERVER'
},
env: 'production', // or 'sandbox'
// The rest of your setup, we'll go into more detail about this later on
PayPal configuration
By coding the flow to ‘checkout’, you can ensure a one-time payment request. Make sure you also mention the amount and currency.
paypal.Button.render({
braintree: braintree,
client: {
production: 'CLIENT_TOKEN_FROM_SERVER',
sandbox: 'CLIENT_TOKEN_FROM_SERVER'
},
env: 'production', // Or 'sandbox'
commit: true, // This will add the transaction amount to the PayPal button
payment: function (data, actions) {
return actions.braintree.create({
flow: 'checkout', // Required
amount: 10.00, // Required
currency: 'USD', // Required
enableShippingAddress: true,
shippingAddressEditable: false,
shippingAddressOverride: {
recipientName: 'Scruff McGruff',
line1: '1234 Main St.',
line2: 'Unit 1',
city: 'Chicago',
countryCode: 'US',
postalCode: '60652',
state: 'IL',
phone: '123.456.7890'
}
});
},
onAuthorize: function (payload) {
// Submit `payload.nonce` to your server.
},
}, '#paypal-button');
Send payment method nonce to server
Braintree receives the customer payment information through the client-side and offers payment method nonce in exchange. This payment method is used on your server to create secure transactions.
Setting Up the Server
Installation and Configuration
Install the Braintree node package
npm install braintree
Construct the Gateway Object
You must first construct a gateway object with the environment-specific access token in your PayPal dashboard.
var gateway = braintree.connect({
accessToken: useYourAccessToken
});
Generate a Client Token
Your server has the responsibility to generate client tokens which include every authorisation and configuration information needed by the client to initialise the communication of client SDK with Braintree.
app.get("/client_token", function (req, res) {
gateway.clientToken.generate({}, function (err, response) {
res.send(response.clientToken);
});
});
Receive payment method nonce from the client
A successful checkout by a customer will lead to your client receiving a payment method nonce, which is then sent to the server to create a transaction.
app.post("/checkout", function (req, res) {
var nonce = req.body.payment_method_nonce;
// Use payment method nonce here
});
Create a transaction
This can be done using the payment method nonce and the amount. You would have to enter the specific currency and the valid shipping address.
You can test the integration using the access token for Braintree sandbox generated in the PayPal Developer Dashboard.
Once the integration has been tested, you can go live using the following actions –
Live configuration
Click on Access Token Page
Request for credentials
Update the access token
Run a transaction test in production
Carry out a test with low-value transactions on the production account
Confirm if the funds have been deposited
Conclusion
The above step-by-step guide gives one a detailed understanding and tutors them to successfully write a PayPal NodeJS code, fulfilling the objective of helping them script the application and integrating a Paypal NodeJS Recurring Payments API.
We hope you had a great time reading this article and it proves to be a wonderful experience for any Node.js Development Company who wants to integrate PayPal in their app.
With the help of Node.js, PayPal developers were able to write browser and server-side code with just one platform. So, the team was able to address the problems in a quicker way. This way the request handling got improved.
With Node.js coming into the picture, the single-threaded event model with an asynchronous approach started to take effect. PayPal was able to remain available for a longer period. So, in this manner, requests were handled.
Way back since 2012, PayPal is utilizing Node.js. In the initial period, it was utilized as a prototype mechanism. But, in recent years, it has become a core part of its architecture. So, the role and importance are greater now.
There are 4 major steps that you need to follow for this task: Step 1: Set Up Client Call To The Server
Step 2: Set Up Server To Call PayPal API
Step 3: Test The Server
Step 4: Go Live
To authorize a payment, create a payment, and set the intent to authorize. It will authorize the PayPal Payment and if the request is successful, you will get a response with all the payment information as well.
Chintan Gor
Enthusiastic for web app development, Chintan Gor has zeal in experimenting with his knowledge of Node.js in various aspects of development. He keeps on updating his technical know-how thus pinning his name among the topmost CTO's in India. His contribution is penned down by him through various blogs on Node.js. He is associated with eSparkBiz - a Node.js Development Company from the past 7-8 years where one can get premium services.
