Node.js Examples

Ready-to-use Node.js code for common Pixlpay API operations.

Setup

Using fetch (Node 18+)

class PixlpayClient {
    constructor(subdomain, apiToken) {
        this.baseUrl = `https://${subdomain}.pixlpay.net/api/external/v1`;
        this.apiToken = apiToken;
    }

    async request(method, endpoint, data = null) {
        const options = {
            method,
            headers: {
                'Authorization': `Bearer ${this.apiToken}`,
                'Accept': 'application/json',
                'Content-Type': 'application/json',
            },
        };

        if (data) {
            options.body = JSON.stringify(data);
        }

        const response = await fetch(`${this.baseUrl}${endpoint}`, options);
        const json = await response.json();

        return {
            status: response.status,
            data: json,
        };
    }

    get(endpoint) {
        return this.request('GET', endpoint);
    }

    post(endpoint, data) {
        return this.request('POST', endpoint, data);
    }
}

module.exports = PixlpayClient;

Fetching Products

const PixlpayClient = require('./pixlpay-client');

const client = new PixlpayClient('yourstore', process.env.PIXLPAY_TOKEN);

async function listProducts() {
    const response = await client.get('/products');

    if (response.status === 200) {
        response.data.data.forEach(product => {
            console.log(`${product.name} - $${product.price}`);
        });
    }
}

// Get single product
async function getProduct(id) {
    const response = await client.get(`/products/${id}`);
    return response.data.data;
}

Fetching Orders

const client = new PixlpayClient('yourstore', process.env.PIXLPAY_TOKEN);

// Get pending orders
async function getPendingOrders() {
    const response = await client.get('/orders?status=pending');
    return response.data.data;
}

// Get orders by date range
async function getOrdersByDate(from, to) {
    const response = await client.get(`/orders?from=${from}&to=${to}`);
    return response.data.data;
}

Fulfilling Orders

const client = new PixlpayClient('yourstore', process.env.PIXLPAY_TOKEN);

async function fulfillOrder(orderId) {
    const response = await client.post(`/orders/${orderId}/fulfill`, {
        note: 'Delivered via API'
    });

    if (response.status === 200) {
        console.log('Order fulfilled successfully!');
        return true;
    }
    return false;
}

Express Webhook Handler

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

const app = express();

function verifySignature(payload, signature, secret) {
    const computed = crypto
        .createHmac('sha256', secret)
        .update(payload)
        .digest('hex');

    return crypto.timingSafeEqual(
        Buffer.from(computed),
        Buffer.from(signature)
    );
}

app.post('/webhooks/pixlpay',
    express.raw({ type: 'application/json' }),
    (req, res) => {
        const signature = req.headers['x-pixlpay-signature'];
        const secret = process.env.PIXLPAY_WEBHOOK_SECRET;

        if (!verifySignature(req.body, signature, secret)) {
            return res.status(401).send('Invalid signature');
        }

        const event = JSON.parse(req.body);

        switch (event.event) {
            case 'order.paid':
                handleOrderPaid(event.data);
                break;
            case 'order.completed':
                handleOrderCompleted(event.data);
                break;
            case 'subscription.cancelled':
                handleSubscriptionCancelled(event.data);
                break;
        }

        res.sendStatus(200);
    }
);

function handleOrderPaid(order) {
    console.log(`Order paid: ${order.order_number}`);
    // Your delivery logic here
}

function handleOrderCompleted(order) {
    console.log(`Order completed: ${order.order_number}`);
}

function handleSubscriptionCancelled(subscription) {
    console.log(`Subscription cancelled: ${subscription.id}`);
}

app.listen(3000);

Creating Webhooks

const client = new PixlpayClient('yourstore', process.env.PIXLPAY_TOKEN);

async function createWebhook() {
    const response = await client.post('/webhooks', {
        url: 'https://yoursite.com/webhooks/pixlpay',
        events: ['order.paid', 'order.completed']
    });

    if (response.status === 201) {
        const webhook = response.data.data;
        console.log(`Webhook created! Secret: ${webhook.secret}`);
        return webhook;
    }
}

Analytics

const client = new PixlpayClient('yourstore', process.env.PIXLPAY_TOKEN);

async function getRevenueStats() {
    const response = await client.get('/analytics/revenue?from=2025-01-01&to=2025-01-31');

    if (response.status === 200) {
        const { total_revenue, total_orders, average_order_value } = response.data.data;
        console.log(`Revenue: $${total_revenue}`);
        console.log(`Orders: ${total_orders}`);
        console.log(`AOV: $${average_order_value}`);
    }
}

Error Handling

const client = new PixlpayClient('yourstore', process.env.PIXLPAY_TOKEN);

async function safeRequest() {
    try {
        const response = await client.get('/products/99999');

        if (response.status !== 200) {
            console.error(`Error: ${response.data.message}`);

            switch (response.status) {
                case 401:
                    console.error('Check your API token');
                    break;
                case 404:
                    console.error('Resource not found');
                    break;
                case 429:
                    console.error('Rate limited - slow down!');
                    break;
            }
        }
    } catch (error) {
        console.error('Network error:', error.message);
    }
}