Let's start with a sample code:

#### Example Nodejs Implementation 

First run `npm install @100pay-hq/100pay.js` to install the [100Pay API wrapper SDK "100pay.js"](https://www.npmjs.com/package/@100pay-hq/100pay.js):

```javascript
  import { _100Pay } from "@100pay-hq/100pay.js";

const verifyCryptoPayment = async (chargeId) => {
  return new Promise( async (resolve, reject) => {
      const _100pay = new _100Pay(process.env._100PAY_PUB_KEY, process.env._100PAY_SEC_KEY)

      const response = await _100pay.verify(chargeId)

      // console.log('verified data ====>', { response })

      if(response.status === 'error') {
        // an error occurred, do something
        // return res.status(400).end()
        return console.log('an error occurred');
      }

      const chargeStatus = response.data.data.charge.status.value;
      
      if(chargeStatus === 'paid' && response.data.data.charge.billing.currency === store.currency.currency){
        // payment received, give the merchant value
        console.log('paid')
        updateOrderStatus(response.data.data.charge.status.total_paid)
      }

      if(chargeStatus === 'underpaid'){
        // customer made a partial payment, send an email to the customer to complete the payment.
        console.log(' ==> underpaid')
      }

      if(chargeStatus === 'overpaid'){
        // customer paid more than what was expected, notify the customer for a balance refund via 100Pay.
        console.log('===> overpaid')
        let newAmount = +response.data.data.charge.status.total_paid - +response.data.data.charge.billing.amount
        updateOrderStatus(newAmount)
        // send customer an email for a balance refund
      }
  })
}

```

Please Note: the above code is for a nodejs environment, do not run on the client side to avoid exposing your private and secret keys.


#### Example php code

The PHP code below uses the cURL library to make HTTP requests and process the response:

```php
<?php

function verifyCryptoPayment($chargeId) {
    $publicKey = 'your_public_key';
    $secretKey = 'your_secret_key';

    $ch = curl_init();

    curl_setopt($ch, CURLOPT_URL, "https://api.100pay.co/api/v1/pay/crypto/payment/$chargeId");
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode(["charge_id" => $chargeId]));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'Content-Type: application/json',
        'api-key ' . $secretKey
    ]);

    $response = curl_exec($ch);
    curl_close($ch);

    $responseData = json_decode($response, true);

    if ($responseData['status'] === 'error') {
        // an error occurred, do something
        echo 'An error occurred';
        return;
    }

    $chargeStatus = $responseData['data']['charge']['status']['value'];

    if ($chargeStatus === 'paid' && $responseData['data']['charge']['billing']['currency'] === $storeCurrency) {
        // payment received, give the merchant value
        echo 'Paid';
        updateOrderStatus($responseData['data']['charge']['status']['total_paid']);
    }

    if ($chargeStatus === 'underpaid') {
        // customer made a partial payment, send an email to the customer to complete the payment.
        echo 'Underpaid';
    }

    if ($chargeStatus === 'overpaid') {
        // customer paid more than what was expected, notify the customer for a balance refund via 100Pay.
        echo 'Overpaid';
        $newAmount = floatval($responseData['data']['charge']['status']['total_paid']) - floatval($responseData['data']['charge']['billing']['amount']);
        updateOrderStatus($newAmount);
        // send customer an email for a balance refund
    }
}

function updateOrderStatus($amount) {
    // Implement the logic to update the order status with the given amount
}

$chargeId = 'your_charge_id'; // Replace with the actual charge ID
verifyCryptoPayment($chargeId);

?>
```

In this PHP code:
- Replace `'your_public_key'` and `'your_secret_key'` with your actual public and secret keys.
- Adjust the logic in the `updateOrderStatus` function to update the order status as needed.
- Replace `'your_charge_id'` with the actual charge ID you want to verify.

Please note that this example uses cURL for making the API request and processing the response. Make sure to adjust the code according to your specific needs and the libraries available in your PHP environment.


Create an endpoint in your backend and call it `verify-crypto-payment`. copy and paste the above code on your backend. Call this endpoint whenever the `onPayment` callback function in the [100Pay checkout](https://www.npmjs.com/package/@100pay-hq/checkout) charge object is trigered on your frontend. You should do this to ensure a malicious user does not trick you to give value for an unpaid transaction.

Cheers 🍻

In this article, I will walk you through verifying crypto payments on 100Pay before giving users value.

How to verify crypto payments on 100pay

## 100Pay Webhook Integration Guide

For 100Pay Checkout documentation, please click here 👉 [100Pay checkout pop-up SDK](https://www.npmjs.com/package/@100pay-hq/checkout)

For API documentation, please click here 👉 [100Pay Developers API documentation](https://documenter.getpostman.com/view/13045730/2s93RMUatE)

### Table of Contents

1. **Introduction to Webhooks**
2. **Why Webhooks are Important**
3. **Security Measures for Webhooks**
4. **Webhook Integration Steps**
   - Setting Up Webhook Endpoint
   - Verifying Webhook Signatures
   - Processing Webhook Data and Updating Database
5. **Example Code Snippets**
   - JavaScript Example
   - Node.js Example

### 1. Introduction to Webhooks

Webhooks are a way for external systems to provide real-time information to your application by sending HTTP POST requests to a designated URL, also known as the webhook endpoint. Webhooks are commonly used for event-driven architectures, such as notifying your application about payment updates, order status changes, or other important events.

### 2. Why Webhooks are Important

Webhooks enable your application to receive immediate updates without the need to repeatedly poll an API for changes. This leads to more efficient resource utilization and faster response times.

### 3. Security Measures for Webhooks

To ensure the security and authenticity of webhook data, consider implementing the following measures:

- **HTTPS**: Use HTTPS for your webhook endpoint to encrypt data during transmission.
- **Signature Verification**: Include a signature in the webhook payload and verify it to ensure the data is from 100Pay.
- **Secret Key**: Use a shared secret key to generate and verify signatures.
- **IP Whitelisting**: Whitelist IP addresses from 100Pay's servers to prevent unauthorized requests.

### 4. Webhook Integration Steps

#### Setting Up Webhook Endpoint

1. In your application, create an endpoint to receive webhook notifications. This endpoint should be accessible via HTTPS.

#### Verifying Webhook Signatures

1. When you receive a webhook request, extract the provided signature and payload.
2. Use your secret key to re-calculate the signature based on the payload.
3. Compare the calculated signature with the received signature to verify authenticity.

#### Processing Webhook Data and Updating Database

1. Parse the JSON payload to extract relevant data, such as payment status, amount, and currency.
2. Compare the received amount and currency with your expected values to ensure consistency.
3. Update your database with the payment status and other relevant information.

⚠️ To enable webhook 🪝 notifications on your 100Pay account, log into your account and click on settings I'm the sidebar menu, next enter your web hook url and your secret key. click on save and that's it.

below are some example codes you can copy and paste. If you should have any issue, feel free to reachout to me.


### 5. Example Code Snippets


#### Example JSON response

```json

{"retries":0,"acknowledged":false,"dispatched":false,"type":"credit","_id":"66deb5e0a7044f0049e24ca3","chargeId":"66deb58ea7044f0049e24c69","reference":"lEdWUHVGoCnUMYG9","data":{"from":"0x8ad4BFe54f00C6B7A394a21405a12bfdd3f97851","to":"160005","network":"bsc","transaction_id":"internal-transfer-66deb5dfa7044f0049e24c96","status":"CONFIRMED","timestamp":"2024-09-09T08:46:24.057Z","value":{"local":{"amount":"242.95","currency":"NGN"},"crypto":{"amount":5,"currency":"PAY"}},"block":{"hash":"internal-transfer-66deb5dfa7044f0049e24c96"},"charge":{"customer":{"user_id":"1","name":"Express User","email":"joshuabrendan5@gmail.com","phone":"0000000000"},"billing":{"currency":"PAY","vat":0,"pricing_type":"fixed_price","amount":"5","description":"test","country":"US"},"status":{"context":{"status":"overpaid","value":142.95},"value":"overpaid","total_paid":242.95},"ref_id":"fb324f73-8733-47e2-b371-8a766235694d","payments":[{"from":"0x8ad4BFe54f00C6B7A394a21405a12bfdd3f97851","to":"160005","network":"bsc","transaction_id":"internal-transfer-66deb5dfa7044f0049e24c96","status":"CONFIRMED","timestamp":"2024-09-09T08:46:24.057Z","value":{"local":{"amount":"242.95","currency":"NGN"},"crypto":{"amount":5,"currency":"PAY"}},"block":{"height":null,"hash":"internal-transfer-66deb5dfa7044f0049e24c96"}}],"charge_source":"external","createdAt":"2024-09-07T12:05:46.431Z","_id":"66deb58ea7044f0049e24c69","metadata":{"is_approved":"yes","order_id":"OR2","charge_ref":"REF"},"call_back_url":"http://localhost:8000/verifyorder/","app_id":"64971290f6dbaf011f729325","userId":"64970fbdf6dbaf011f7292be","chargeId":"66deb58ea7044f0049e24c69","__v":0},"appId":"64971290f6dbaf011f729325"},"cryptoChargeId":"66deb593a7044f0049e24c73","createdAt":"2024-09-09T08:46:24.477Z","__v":0}

```

The above JSON data sample is for reference purposes only. The data 100pay will send to your server will be in this exact format.

#### Node.js Example

```javascript

const express = require('express');
const mongoose = require('mongoose');

const app = express();
const YOUR_SECRET_KEY = 'your_secret_key';
const MONGO_URI = 'mongodb://localhost:27017/your_database_name';

// Define a mongoose model for payments
const Payment = mongoose.model('Payment', {
    transaction_id: String,
    network: String,
    status: String,
    timestamp: Date,
    value: {
        local: {
            amount: Number,
            currency: String
        },
        crypto: {
            amount: Number,
            currency: String
        }
    }
});

mongoose.connect(MONGO_URI, { useNewUrlParser: true, useUnifiedTopology: true });

async function isPaymentProcessed(transactionId) {
    const existingPayment = await Payment.findOne({ transaction_id: transactionId });
    return existingPayment !== null;
}

async function updateDatabase(payload) {
    const newPaymentTransactionId = payload.new_payment.transaction_id;

    // Check whether newPaymentTransactionId already exists in the database
    if (!await isPaymentProcessed(newPaymentTransactionId)) {
        const payment = new Payment(payload.new_payment);
        await payment.save();
        console.log(`Payment with transaction ID ${newPaymentTransactionId} processed and logged.`);
    } else {
        console.log(`Payment with transaction ID ${newPaymentTransactionId} already processed.`);
    }

    // Update charge status in the database based on the "value" field
    const chargeStatus = payload.charge.status.value;
    if (chargeStatus === 'paid') {
        console.log('Charge status updated: Paid');
        // Update the charge status in the database to "Paid"
    } else if (chargeStatus === 'overpaid' || chargeStatus === 'underpaid') {
        const overpaidValue = payload.charge.status.context.value;
        console.log(`Charge status updated: ${chargeStatus.charAt(0).toUpperCase() + chargeStatus.slice(1)}. Over/underpaid amount: ${overpaidValue}`);
        // Update the charge status in the database to "Overpaid" or "Underpaid"
    }
}

app.use(express.json());

app.post('/webhook', async (req, res) => {
    const receivedToken = req.headers['verification-token'];

    if (receivedToken === YOUR_SECRET_KEY) {
        const payload = req.body;

        // Verify the webhook request
        if (await isPaymentProcessed(payload.new_payment.transaction_id)) {
            await updateDatabase(payload);
            res.send('Webhook received and payment processed');
        } else {
            res.status(400).send('Payment already processed or invalid');
        }
    } else {
        res.status(403).send('Webhook verification failed');
    }
});

app.listen(3000, () => {
    console.log('Webhook server started on port 3000');
});

```
The above sample code is writen for a nodejs environment. You may have to adjust it to meet your project goals.

#### PHP and mysql Example

This PHP script handles the webhook request, verifies it, checks if the payment is processed, and updates the MySQL database accordingly. It echoes messages to indicate the processing steps.

Feel free to use this code as a reference for handling webhooks and MySQL database operations in PHP, and if you have any further questions or need additional assistance, please let me know!

###### Here you go:

```php
<?php

$YOUR_SECRET_KEY = 'your_secret_key';
$MYSQL_HOST = 'localhost';
$MYSQL_USER = 'your_mysql_user';
$MYSQL_PASSWORD = 'your_mysql_password';
$MYSQL_DATABASE = 'your_database_name';

$connection = mysqli_connect($MYSQL_HOST, $MYSQL_USER, $MYSQL_PASSWORD, $MYSQL_DATABASE);

function isPaymentProcessed($transactionId) {
    global $connection;
    $query = "SELECT * FROM payments WHERE transaction_id = '$transactionId'";
    $result = mysqli_query($connection, $query);
    return mysqli_num_rows($result) > 0;
}

function updateDatabase($payload) {
    global $connection;

    $newPaymentTransactionId = $payload['new_payment']['transaction_id'];

    if (!isPaymentProcessed($newPaymentTransactionId)) {
        $localAmount = $payload['new_payment']['value']['local']['amount'];
        $localCurrency = $payload['new_payment']['value']['local']['currency'];
        $query = "INSERT INTO payments (transaction_id, local_amount, local_currency) VALUES ('$newPaymentTransactionId', $localAmount, '$localCurrency')";
        mysqli_query($connection, $query);
        echo "Payment with transaction ID $newPaymentTransactionId processed and logged.\n";
    } else {
        echo "Payment with transaction ID $newPaymentTransactionId already processed.\n";
    }

    $chargeStatus = $payload['charge']['status']['value'];
    if ($chargeStatus === 'paid') {
        echo "Charge status updated: Paid\n";
    } elseif ($chargeStatus === 'overpaid' || $chargeStatus === 'underpaid') {
        $overpaidValue = $payload['charge']['status']['context']['value'];
        echo "Charge status updated: " . ucfirst($chargeStatus) . ". Over/underpaid amount: $overpaidValue\n";
    }
}

$payload = json_decode(file_get_contents('php://input'), true);
$receivedToken = $_SERVER['HTTP_VERIFICATION_TOKEN'];

if ($receivedToken === $YOUR_SECRET_KEY) {
    if (isPaymentValid($payload)) {
        updateDatabase($payload);
        echo "Webhook received, verified, and payment processed\n";
    } else {
        http_response_code(400);
        echo "Payment already processed or invalid\n";
    }
} else {
    http_response_code(403);
    echo "Webhook verification failed\n";
}

mysqli_close($connection);

?>
```

Please replace `'your_secret_key'`, `'your_mysql_user'`, `'your_mysql_password'`, and `'your_database_name'` with the appropriate values.


#### go and Mongodb example 


I've also included an example implementation in go. please adjust it to meet your project goals.

```go
package main

import (
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"time"

	"github.com/gorilla/mux"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

const (
	yourSecretKey = "your_secret_key"
	mongoURI      = "mongodb://localhost:27017"
	databaseName  = "your_database_name"
	collectionName = "payments"
)

type Payment struct {
	TransactionID string    `bson:"transaction_id"`
	Network       string    `bson:"network"`
	Status        string    `bson:"status"`
	Timestamp     time.Time `bson:"timestamp"`
	Value         struct {
		Local struct {
			Amount   float64 `bson:"amount"`
			Currency string  `bson:"currency"`
		} `bson:"local"`
		Crypto struct {
			Amount   float64 `bson:"amount"`
			Currency string  `bson:"currency"`
		} `bson:"crypto"`
	} `bson:"value"`
}

func isPaymentProcessed(transactionID string, collection *mongo.Collection) bool {
	filter := bson.M{"transaction_id": transactionID}
	count, err := collection.CountDocuments(nil, filter)
	if err != nil {
		log.Println("Error checking payment:", err)
		return false
	}
	return count > 0
}

func updateDatabase(payload map[string]interface{}, collection *mongo.Collection) {
	payment := payload["new_payment"].(map[string]interface{})
	transactionID := payment["transaction_id"].(string)

	if !isPaymentProcessed(transactionID, collection) {
		_, err := collection.InsertOne(nil, payment)
		if err != nil {
			log.Println("Error inserting payment:", err)
			return
		}
		fmt.Printf("Payment with transaction ID %s processed and logged.\n", transactionID)
	} else {
		fmt.Printf("Payment with transaction ID %s already processed.\n", transactionID)
	}

	chargeStatus := payload["charge"].(map[string]interface{})["status"].(map[string]interface{})["value"].(string)
	if chargeStatus == "paid" {
		fmt.Println("Charge status updated: Paid")
	} else if chargeStatus == "overpaid" || chargeStatus == "underpaid" {
		overpaidValue := payload["charge"].(map[string]interface{})["status"].(map[string]interface{})["context"].(map[string]interface{})["value"].(float64)
		fmt.Printf("Charge status updated: %s. Over/underpaid amount: %f\n", chargeStatus, overpaidValue)
	}
}

func webhookHandler(w http.ResponseWriter, r *http.Request) {
	receivedToken := r.Header.Get("Verification-Token")

	if receivedToken == yourSecretKey {
		var payload map[string]interface{}
		decoder := json.NewDecoder(r.Body)
		if err := decoder.Decode(&payload); err != nil {
			http.Error(w, "Invalid payload", http.StatusBadRequest)
			return
		}

		client, err := mongo.Connect(nil, options.Client().ApplyURI(mongoURI))
		if err != nil {
			log.Fatal(err)
		}
		defer client.Disconnect(nil)

		db := client.Database(databaseName)
		collection := db.Collection(collectionName)

		if isPaymentValid(payload) {
			updateDatabase(payload, collection)
			w.WriteHeader(http.StatusOK)
			fmt.Fprintln(w, "Webhook received, verified, and payment processed")
		} else {
			w.WriteHeader(http.StatusBadRequest)
			fmt.Fprintln(w, "Payment already processed or invalid")
		}
	} else {
		w.WriteHeader(http.StatusForbidden)
		fmt.Fprintln(w, "Webhook verification failed")
	}
}

func isPaymentValid(payload map[string]interface{}) bool {
	// Implement payment validation logic here based on payload
	return true
}

func main() {
	router := mux.NewRouter()
	router.HandleFunc("/webhook", webhookHandler).Methods("POST")

	serverAddr := "localhost:3000"
	fmt.Printf("Webhook server started on %s\n", serverAddr)
	log.Fatal(http.ListenAndServe(serverAddr, router))
}
```

Please replace `"your_secret_key"`, `"your_database_name"`, and implement the `isPaymentValid` function for your specific validation logic.

This Go script uses the Gorilla Mux router and the MongoDB Go driver for handling webhooks and interacting with the MongoDB database.

Feel free to use this code as a reference for handling webhooks and MongoDB operations in Go, and if you have any further questions or need additional assistance, please let me know!



This technical documentation provides a comprehensive guide to integrating 100Pay's webhooks into your application. It covers the importance of webhooks, security considerations, and step-by-step instructions along with example code snippets in JavaScript and Node.js. By following these guidelines, you can effectively receive and process webhook notifications, ensuring accurate payment updates and database management.

If you have any further questions or need assistance, feel free to reach out to our support team at support@100pay.com.


In this article, I will show you how to enable webhooks on your 100pay account and listen for new payment notifications.

How to subscribe to webhook notifications on 100Pay

Brainy Josh

large_DSC_0814-2 Large.jpeg

medium_DSC_0814-2 Large.jpeg

small_DSC_0814-2 Large.jpeg

thumbnail_DSC_0814-2 Large.jpeg

DSC_0814-2 Large.jpeg

twitter

instagram

linkedin

youtube

website

Founder & CEO

Ugo Matt

medium_ugo-matt.jpeg

small_ugo-matt.jpeg

thumbnail_ugo-matt.jpeg

ugo-matt.jpeg

 COO & Senior Business Executive

Ogele Clinton

small_ogele-clinton-min.jpeg

thumbnail_ogele-clinton-min.jpeg

ogele-clinton-min.jpeg

CFO & Head of Business

Philips Obaje

large_photo_2023-11-06 11.34.37.jpeg

medium_photo_2023-11-06 11.34.37.jpeg

small_photo_2023-11-06 11.34.37.jpeg

thumbnail_photo_2023-11-06 11.34.37.jpeg

photo_2023-11-06 11.34.37.jpeg

 International Relations & Shipping @ Shop100

Augustine Rita London

Screenshot 2024-03-12 at 12.03.43 (1).jpg

large_Screenshot 2024-03-12 at 12.03.43 (1).jpg

medium_Screenshot 2024-03-12 at 12.03.43 (1).jpg

small_Screenshot 2024-03-12 at 12.03.43 (1).jpg

thumbnail_Screenshot 2024-03-12 at 12.03.43 (1).jpg

linkedIn

github

Front end Developer

Lekia Meneyiibe Jeremiah

large_mene1.png

medium_mene1.png

small_mene1.png

thumbnail_mene1.png

mene1.png

Brand Designer

Egwu Christian

thumbnail_1686224845891 (1).jfif

1686224845891 (1).jfif

behance

Product designer

### Intro

Well, well, well, I've been away for a while but I've come bearing gifts, in this piece we'll have an overview of how to implement crypto payment as a seamless payment option to your eCommerce application using the [**100Pay**](https://100pay.co/) APIs.

Transition beyond the mundane Fiat compatibility and give your application extra flexibility with 100Pay. [100Pay](https://100pay.co/) is a platform that offers everyone; **I**aa**S**, **P**aa**S** and **S**aa**S** a means to accept cryptocurrency payments. 100Pay supports over 20 Cryptocurrencies and syncs with over 10 Blockchains which gives much needed versatility.

There are a few means to integrating the 100Pay payment checkout in your application such as SDKs, API endpoints and a coverage of client and server side libraries which supports several languages/frameworks ranging from React and Vue.js to Node.js and Python, depending on your preference you can refer the [docs](https://100pay.co/integrations) to get your know-how. However, in this article we'll be integrating the 100Pay checkout with her APIs using Node.js. Now enough with the hype, let's get down to business.

### Logic

So the logic is quite simple, the goal is to generate a payment payload containing details such as amount, currency, billing address, customer details, network, recipient, transaction ID, wallet address, etc. This payload is used for payment from any preferred crypto platform that supports the network blockchain. The payment is then confirmed using a webhook. A webhook is a software architecture approach that allows applications and services to submit a web-based notification to other applications whenever a specific event occurs, in our case the event is a payment. Under the hood, webhooks are regular HTTP requests and are handled as such. The webhook is basically an endpoint in your API that you'll setup independently to handle event notification, we'll set this up later in the article.

After payment, a notification is sent to your webhook, this notification is then verified by a secret key that you will also setup later on both your code and your 100Pay account to validate that the payment payload is genuine.

The payload 100Pay sends to your server is of this structure:

NOTE: *this is just dummy data...*

```json
{
    "charge": {
        "customer": {
            "user_id": "001",
            "name": "Isreal Hogan",
            "phone": "+2347000000000",
            "email": "hoganizy85@gmail.com"
        },
        "billing": {
            "currency": "NGN",
            "vat": 0,
            "pricing_type": "fixed_price",
            "amount": "600",
            "description": "Payment for your Shop100 Order",
            "country": "NG"
        },
        "status": {
            "context": {
                "status": "overpaid",
                "value": 491.45
            },
            "value": "overpaid",
            "total_paid": 1091.45
        },
        "ref_id": "966795153",
        "payments": [
            {
                "network": "algorand",
                "transaction_id": "JOVSHQ6XZSAXE7A6JWUV4H34ODNDTEVHIKZJANIAOOD6ZH5K452A",
                "status": "CONFIRMED",
                "timestamp": "2023-03-29T03:04:39.615Z",
                "value": {
                    "local": {
                        "amount": 155.92384371911047,
                        "currency": "NGN"
                    },
                    "crypto": {
                        "amount": 1,
                        "currency": "ALGO"
                    }
                },
                "block": {
                    "height": null,
                    "hash": "JOVSHQ6XZSAXE7A6JWUV4H34ODNDTEVHIKZJANIAOOD6ZH5K452A"
                }
            },
            {
                "network": "algorand",
                "transaction_id": "POKAKNBB3ZOXC7MK2QTXR65UA3R4OYDGDV2RWFHQP4YYZ5DKGHAQ",
                "status": "CONFIRMED",
                "timestamp": "2023-03-29T03:04:54.636Z",
                "value": {
                    "local": {
                        "amount": 311.84768743822093,
                        "currency": "NGN"
                    },
                    "crypto": {
                        "amount": 2,
                        "currency": "ALGO"
                    }
                },
                "block": {
                    "height": null,
                    "hash": "POKAKNBB3ZOXC7MK2QTXR65UA3R4OYDGDV2RWFHQP4YYZ5DKGHAQ"
                }
            },
            {
                "network": "algorand",
                "transaction_id": "JHT3RK2KQHMLKA24QR7JLPWXIMX7O2J4KKF7TL2I3NRVLC7RDELQ",
                "status": "CONFIRMED",
                "timestamp": "2023-03-29T03:09:38.251Z",
                "value": {
                    "local": {
                        "amount": 623.681562705202,
                        "currency": "NGN"
                    },
                    "crypto": {
                        "amount": 4,
                        "currency": "ALGO"
                    }
                },
                "block": {
                    "height": null,
                    "hash": "JHT3RK2KQHMLKA24QR7JLPWXIMX7O2J4KKF7TL2I3NRVLC7RDELQ"
                }
            }
        ],
        "charge_source": "external",
        "createdAt": "2023-03-29T02:16:13.825Z",
        "_id": "64239ff59b4e7700379c2106",
        "metadata": {
            "order_id": "64239ff4d1460e004b199e04",
            "charge_ref": "64239ff4d1460e004b199e04",
            "customer_id": "622f8f67f8c81600420d7769",
            "store_id": "62bee01ccbec51004d585ee1",
            "store_email": "joshuabrendan5@gmail.com"
        },
        "call_back_url": "https://web.shop100.store/thank-you-page/",
        "app_id": "642367e95f09730038029f87",
        "userId": "642366ba5f09730038029f55",
        "chargeId": "64239ff59b4e7700379c2106",
        "__v": 0
    },
    "new_payment": {
        "network": "algorand",
        "transaction_id": "JHT3RK2KQHMLKA24QR7JLPWXIMX7O2J4KKF7TL2I3NRVLC7RDELQ",
        "status": "CONFIRMED",
        "timestamp": "2023-03-29T03:09:38.251Z",
        "value": {
            "local": {
                "amount": "623.68",
                "currency": "NGN"
            },
            "crypto": {
                "amount": 4,
                "currency": "ALGO"
            }
        },
        "block": {
            "hash": "JHT3RK2KQHMLKA24QR7JLPWXIMX7O2J4KKF7TL2I3NRVLC7RDELQ"
        }
    }
}
```

---

### Implementation

**Step 1**: create a 100Pay account by heading to the official [website](https://100pay.co/) and signing up. Your account will be used to generate public/secret keys associated with your account, this will be needed for third party integration. After a successful signup, you will be met with a dashboard that **currently** looks like this:

![100Pay dashboard](https://res.cloudinary.com/estaterally/image/upload/v1711561337/100_Pay_dashboard_2b966d2ad3.jpg)

**Step 2**: next, navigate to the settings menu from your dashboard, here you'll get your public key which you'll provide in your request headers in order to generate the payment payload.

![100Pay public key](https://res.cloudinary.com/estaterally/image/upload/v1711561437/100_Pay_public_key_300b66a68e.jpg)

**Step 3**: the third step is to create a payment charge. We will do this by calling the 100Pay endpoint with [axios](https://www.npmjs.com/package/axios?activeTab=readme). If you don't have axios installed then run this command: `npm install axios`. As earlier mentioned, we'll be using Node.js in an ES6 syntax for implementation. Next, create a file and add the following code, I'll name this file `paymentController.js`

```javascript
import axios from "axios";
import { json } from "express";

export const createPaymentCharge = async (data) => {
  try {
    let config = {
      method: 'post',
      maxBodyLength: Infinity,
      url: 'https://api.100pay.co/api/v1/pay/charge',
      headers: { 
        'api-key': process.env.PAY_API_PUBLIC_KEY, 
        'Content-Type': 'application/json'
      },
      data: data
    };
    const response = await axios.request(config);
    return response.data;
  } catch (error) {
    return json(error) ; 
  }
};
```

The code above uses an axios post method to call the 100Pay Endpoint that creates a payment charge with the data parameter. It sets your API key as a request header, this key is the public key you got from your 100Pay dashboard, in my case I added it as an environment variable for extra safety and then referenced it in my function, *easy peasy*.

**Step 4**: create an endpoint that executes the create payment charge feature:

```javascript
import { createPaymentCharge } from "../controllers/paymentController.js";
import { Router } from "express";
export const paymentRouter = Router()

paymentRouter.post('/create-payment-charge', async (req, res) => {
    try {
        const { customer, billing, metadata, call_back_url, ref_id, charge_source } = req.body
        if (!req.body) {
            return res.status(400).json({ error: 'No data provided' })
        }
        const payment = await createPaymentCharge({ ref_id, customer, billing, metadata, call_back_url, userId, charge_source })
        return res.status(201).json(payment)
    } catch (error) {
        res.status(500).json({ error: error.message })
    }
})
```

This route is setup to create a payment charge, it requires that the user fills in certain fields to be parsed into the request body such as amount, currency, value, etc, you can reference the earlier payload sample for the structure of this data. On successful charge creation, the endpoint returns a couple of metadata, among this data is the `hosted_url`, this URL leads to a payment popup that looks like this

![100Pay charge](https://res.cloudinary.com/estaterally/image/upload/v1711561730/100_Pay_charge_0a88a8829f.png)

As seen, this 100Pay popup offers various selection of cryptocurrencies that the user can pay with such as BTC, USDT, XRP, etc. After crypto selection, a wallet address & QR code is generated for the payment, you can add the wallet id or scan the QR code from your crypto platform and specify the blockchain network to make payment. **Hold your horses though**! we need to add a webhook verification first before you can proceed to make a payment.

Before we create a webhook to handle the event notification, we will first create a schema that stores the event data that hits our webhook in our Database for extra verification purposes.

**Step 5**: Create a mongoose schema for the necessary payload details, the structure of this schema field is based on your choice, it really depends on how much data on the transaction you want to store in your database. In your schema file, add the following: `webhookSchema.js`

```javascript
import mongoose from "mongoose";

const PaymentSchema = new mongoose.Schema({
    transaction_id: {
        type: String
    },
    network: {
        type: String
    },
    status: {
        type: String
    },
    value: {
        local: {
            amount: Number,
            currency: String
        },
        crypto: {
            amount: Number,
            currency: String
        }
    }
}, {
    timestamps: true
} );

export default mongoose.model('Payment', PaymentSchema);
```

This code creates a schema with the fields: `transaction_id, network, value, status`, etc. These specified fields will be filled from the event data and added to our Mongo DB Payment collection.

**Step 6**: Create a function that checks if the incoming payload's transaction id already exists in your database, this adds a layer of security to your application to invalidate dual transactions. In the case that the transaction Id doesn't exist which means the transaction is new and valid, it creates a new entry in our DB collection. I'll name this file `webhookController.js`:

```javascript
import Payment from "../models/paymentSchema.js";
import { json } from "express";

export async function isPaymentProcessed(transactionId) {
    const existingPayment = await Payment.findOne({ transaction_id: transactionId });
    if (existingPayment) {
        return true;
    } else {
        return false;
    }
}

export async function updateDatabase(payload) {
    const newPaymentTransactionId = payload.data.transaction_id;
    if (!await isPaymentProcessed(newPaymentTransactionId)) {
        const payment =  await Payment.create(payload.data);
    } else {
        return json({error: "Transaction already processed."})
    }
}
```

The `isPaymentProcessed` function compares the transaction\_id in our collection and checks for duality, if there is no duality then it proceeds to create an entry in our collection with the `updateDatabase` function.

**Step 7**: create an endpoint for your webhook. This endpoint will utilise a secret key that we will use as a request header for our webhhok.

```javascript
import { isPaymentProcessed, updateDatabase } from "../controllers/webhookController.js";
import { Router } from 'express'
export const webhookRouter = Router()

webhookRouter.post('/', async (req, res) => {
    const receivedToken = req.headers['verification-token'];
    if (receivedToken === process.env.WEBHOOK_SECRET_KEY) {
        const payload = req.body;
        // Verify the webhook request
        if (!await isPaymentProcessed(payload.data.transaction_id)) {
            await updateDatabase(payload);
            res.status(200).json({msg:'Webhook received and payment processed'});
        } else {
            res.status(400).json({error:'Payment already processed or invalid'});
        }
    } else {
        res.status(403).status({error:'Webhook verification failed'});
    }
});
```

An express router is created for this endpoint name `webhookRouter,` it then references the secret token from the request headers. This token is the unique secret key that will be created by you and added to your webhook configuration on your 100Pay account. It can be any random value you choose to use.

**Step 8**: Add the webhook endpoint and secret key to your 100Pay account. By navigating to your settings in your 100Pay dashboard, input your webhook URL and secret key in the fields provided. After input, be sure to save the new changes.

![100Pay webhook](https://res.cloudinary.com/estaterally/image/upload/v1711561916/webhook_241a81c233.jpg)

### Outro

Now you can go ahead and make a payment and watch the magic happen. With that comes the curtains closing, in case you run into errors :) review this article, backtrack your code and you could also refer the official 100Pay [official documentation](https://documenter.getpostman.com/view/13045730/2s93RMUatE) for further clarification. Good luck, *hasta luego...*

Adding a Dash of Crypto Magic to Your Payment Options

Isreal Hogan

large_pic.jpg

medium_pic.jpg

small_pic.jpg

thumbnail_pic.jpg

pic.jpg

Backend Developer

This guide will show you easy methods you can use to purchase Pay Tokens, with a focus on funding the Contest app.

## Introduction

One can use different methods to acquire Pay Tokens, with the fastest and most streamlined process being the [100Pay Dashboard](https://dashboard.100pay.co/). This platform is fast and attracts zero(0) fees, allowing you to get the complete value of your money. Let's explore how you can leverage this platform to purchase Pay Tokens, after which we will explore alternatives.

## Using the 100Pay Dashboard

The 100Pay Dashboard is a user-friendly platform designed to receive and send crypto payments, manage businesses, and facilitate easy and secure transactions with Pay Tokens and other cryptocurrencies. Let me walk you through the step-by-step process of purchasing Pay Tokens using the 100Pay Dashboard. Using the Dashboard, we will discuss two options for getting Pay Tokens: depositing and swapping coins to Pay or buying from a 100Pay merchant with your local currency.

### Swapping Other Cryptocurrencies to Pay Tokens

On the Dashboard, you can deposit other popular cryptocurrencies, such as BTC, USDT, SOL, etc., and swap them to the equivalent in Pay Tokens at no transaction charge. To get Pay Tokens using this method, follow the steps outlined below:

* Sign in to the 100Pay Dashboard (or create a new account if you are not already an existing user) and set up your transaction pin (which authorizes actions performed on your 100Pay account).
    

![image.png](https://res.cloudinary.com/estaterally/image/upload/v1726142206/image_4f9bd84944.png)

* On the *Assets* page, select the cryptocurrency you wish to deposit and click on the “Receive” button on the new page that opens. Here, it checks if you previously had a wallet for that coin on the platform and provides an option to generate a new wallet.
    
* If you do not already have a wallet, click the “Generate Wallet” button. The platform automatically creates a wallet that can receive the selected cryptocurrency. Currently, you will have a generated QR code you can scan and a wallet address you can share to receive the selected Crypto on the Bep20(BSC) network.
    

![ScreenRecording2024-09-11at5.30.09PM-ezgif.com-video-to-gif-converter.gif](https://res.cloudinary.com/estaterally/image/upload/v1726142216/Screen_Recording2024_09_11at5_30_09_PM_ezgif_com_video_to_gif_converter_9fee19799b.gif)

In the screen recorded above, I created a wallet for USDT on the Dashboard. I can deposit my USDT on the BSC network and swap it for Pay Tokens.

* Deposit cryptocurrency to your account using the generated wallet information and refresh the page to see an update on your available balance (follow step 2 and create a wallet for Pay Tokens before moving to the next step).
    
* Next, on the USDT asset page, enter the amount of USDT you wish to convert and take note of the Pay Token equivalent, as that is what you will receive in your Pay Token wallet, and click on the “Convert” button to exchange the specified amount of the selected coin for Pay.
    

### Purchasing Pay Tokens on Merchant P2P

Alternatively, suppose you do not have cryptocurrencies to swap and want to purchase with your Fiat (local currencies) instead. In that case, 100Pay also provides a merchant P2P platform with verified merchants available to sell Pay around the clock. Using this service, you can enter the amount you wish to buy, see the equivalent amount of Pay to be received, place an order, and receive Pay Tokens sent to your 100Pay Pay Token Wallet using your unique Pay ID. The platform accounts for all merchants, and you can quickly contact the merchant or support in the occurrence of any issues; as such, you don't have to worry about not receiving the tokens you purchase.

To buy Pay using Fiat:

1. Open the *Assets Page* and select "P2P trading" from the Quick Action options.
    
2. Select the trader (e.g Satoshi) you wish to purchase from and click the "Buy Pay" button.
    
3. Enter the amount you wish to purchase, enter your Pay ID (which can be obtained from your Assets page), and click "Buy." The merchant's account information is displayed. After making the transaction, click the "I have sent Payment" button to finalize it.
    

![buy pay via p2p merchant](https://paper-attachments.dropboxusercontent.com/s_1750E7724A7058447E07BAD610F4EDCBA12C76196E57E8347E69DAC91DF26F6C_1726142997160_Recording2024-09-12084945-ezgif.com-video-to-gif-converter.gif)

4. Within 5-15 minutes, the Pay Merchant will confirm the transaction and send the Pay Token to your wallet, after which you will be notified via email of the credit transaction. If you look at your transaction history for your Pay Tokens there will be a credit transaction for the coins you bought, sent by the merchant.
    

![Recording2024-09-12084945-ezgif.com-video-to-gif-converter_(1).gif](https://res.cloudinary.com/estaterally/image/upload/v1726142214/Recording2024_09_12084945_ezgif_com_video_to_gif_converter_1_25c482593f.gif)

### Sending Pay Tokens from the Dashboard to the Contest App

Using either of the two methods described above, you would currently be holding Pay Tokens in your 100Pay dashboard wallet, but your main goal is to fund your Contest App account. Let me guide you through a sequence of steps to achieve that.

* Navigate back to the *Assets Page* and select Pay Tokens. Click on “Withdraw” and select “Send Internal”. Open the Contest app, go to the *Profile Screen,* Click “Fund Wallet,” and click “Pay with 100pay checkout”. This option allows you to fund directly from your 100 Pay dashboard at zero fees.
    

![Recording2024-09-12110527-ezgif.com-video-to-gif-converter.gif](https://res.cloudinary.com/estaterally/image/upload/v1726142210/Recording2024_09_12110527_ezgif_com_video_to_gif_converter_ef8a5a9bbb.gif)

* In the input box, enter the amount you wish to deposit and click on “Continue.” The amount you enter doesn’t have to be precisely the amount you would be depositing; it can be higher or lesser. It loads the 100Pay checkout and shows you the option to use 100Pay Tokens for payment on the BSC network.
    

![Recording2024-09-12110527-ezgif.com-video-to-gif-converter_(1).gif](https://res.cloudinary.com/estaterally/image/upload/v1726142212/Recording2024_09_12110527_ezgif_com_video_to_gif_converter_1_cbb22ea99c.gif)

* In the generated information, it provides a “Pay ID” and a reference code, which you will need to copy and enter on the “internal Send” in the 100Pay dashboard, along with the amount and transaction pin to send money to your Contest App account at lightning speed. For this example, I am using the Nano Apps platform as it allows me to switch effortlessly between applications.
    

![switching to dashboard and funding with internal send](https://paper-attachments.dropboxusercontent.com/s_1750E7724A7058447E07BAD610F4EDCBA12C76196E57E8347E69DAC91DF26F6C_1726143022523_Recording2024-09-12110527-ezgif.com-video-to-gif-converter_2.gif)

* Within seconds, you will receive a notification on the Contest App informing you that a payment has been detected. You can view all payments by clicking on the action button “My Payments.” Close the checkout modal after confirming receipt of the funded amount.
    

![funding successful](https://paper-attachments.dropboxusercontent.com/s_1750E7724A7058447E07BAD610F4EDCBA12C76196E57E8347E69DAC91DF26F6C_1726143037425_Recording2024-09-12110527-ezgif.com-video-to-gif-converter_4.gif)

Congratulations 🎉 you have successfully funded your Contest App account.

## Alternative Purchase of Pay Tokens from an Exchange

Pay Token is currently listed and trading on the [XT platform](http://xt.com/). You can deposit USDT and buy Pay Tokens on the exchange. Afterward, you can withdraw the coin to the Pay deposit wallet address on the Contest App “Fund Wallet” option using either the generated wallet address or scanning the QR code.

The major demerit of this approach is the amount of Pay that will be paid as a transaction charge and the existence of a fixed minimum withdrawal amount, which is slightly high.

This guide presents readers with descriptive info on how they can get Pay Tokens either by direct purchase, or swapping coins they own for Pay, at no transaction cost.

How to buy Pay Tokens

Victory Tuduo

large_IMG_20240122_110632.jpg

medium_IMG_20240122_110632.jpg

small_IMG_20240122_110632.jpg

thumbnail_IMG_20240122_110632.jpg

IMG_20240122_110632.jpg

Front-end Developer

Emmanuel Duke

WhatsApp Image 2024-03-25 at 14.22.48_76125978.jpg

large_WhatsApp Image 2024-03-25 at 14.22.48_76125978.jpg

medium_WhatsApp Image 2024-03-25 at 14.22.48_76125978.jpg

small_WhatsApp Image 2024-03-25 at 14.22.48_76125978.jpg

thumbnail_WhatsApp Image 2024-03-25 at 14.22.48_76125978.jpg

Senior Product Designer

Afonime Royal

small_144e6e99-c6c2-4201-aafa-f444a79bf1e8.JPG

thumbnail_144e6e99-c6c2-4201-aafa-f444a79bf1e8.JPG

144e6e99-c6c2-4201-aafa-f444a79bf1e8.JPG

Fullstack Developer

About Us

100 Team

Meet the amazing minds driving innovation

FAQ

Frequently Asked Questions

Products

Use Cases

Developers

Resources

Legals

About Us

100 Team

Meet the amazing minds driving innovation

Get Started with 100pay for free — 0% fees

FAQ

Frequently Asked Questions

How does a crypto payment gateway work?

Can you show me an example?

Where can I spend 100Pay tokens?

Where can I trade 100pay tokens?

How can I buy 100pay tokens?

Who can buy 100pay token?

Join the PAY Crypto card Waitlist. up to $1m In monthly spending Limit.