Node.js SDK

import { Pocketsflow } from 'pocketsflow';

const pf = new Pocketsflow({
  apiKey: 'pk_live_your_api_key_here',
});

// List all products
const products = await pf.products.list();
console.log(products);

const pf = new Pocketsflow({
  apiKey: 'pk_live_your_api_key_here', // Required
  baseUrl: 'https://api.pocketsflow.com', // Optional, defaults to production
  timeout: 30000, // Optional, request timeout in milliseconds
});

const products = await pf.products.list();

const product = await pf.products.get('product_id');

const product = await pf.products.create({
  name: 'Premium Course',        // Required
  price: 99.99,                  // Required
  description: 'Learn everything about...', // Optional
  subtitle: 'The complete guide',           // Optional
  published: true,               // Optional (default: true)
  slug: 'premium-course',        // Optional
  thumbnail: 'https://...',      // Optional
  images: ['https://...'],       // Optional
  showSales: true,               // Optional (default: true)
  showReviews: true,             // Optional (default: true)
  refundPolicy: '30-day money back guarantee', // Optional
  hasFirstName: true,            // Optional - collect first name
  hasLastName: true,             // Optional - collect last name
  payWant: false,                // Optional - pay what you want
  minPrice: 10,                  // Optional - for pay what you want
  maxPrice: 100,                 // Optional - for pay what you want
});

const updated = await pf.products.update('product_id', {
  name: 'Updated Name',
  price: 149.99,
});

await pf.products.delete('product_id');

const variant = await pf.variants.create({
  productId: 'product_id',
  name: 'Premium Version',
  price: 149.99,
});

await pf.variants.delete('variant_id');

const { orders, pagination } = await pf.orders.list({
  page: 1,
  pageSize: 20,
  startDate: '2024-01-01',
  endDate: '2024-12-31',
  productId: 'product_id', // optional filter
});

console.log(`Found ${pagination.totalCount} orders`);
console.log(`Page ${pagination.currentPage} of ${pagination.totalPages}`);

const order = await pf.orders.get('order_id');

const customers = await pf.customers.list({
  email: 'customer@example.com', // optional filter
  sortBy: 'createdAt',
  sortOrder: 'desc',
  limit: 100,
  offset: 0,
});

const customer = await pf.customers.get('customer_id');

// All reviews
const reviews = await pf.reviews.list();

// Filter by product
const productReviews = await pf.reviews.list({
  productId: 'product_id',
});

const discounts = await pf.discounts.list();

const discount = await pf.discounts.get('discount_id');

const discount = await pf.discounts.create({
  name: 'Summer Sale',           // Required
  code: 'SUMMER20',              // Required - what customers enter
  mainProductIds: ['product_id_1', 'product_id_2'], // Required
  value: 20,                     // Required
  valueType: 'percentage',       // Optional (default: 'percentage') - or 'fixed'
  active: true,                  // Optional (default: true)
  expiration: '2024-12-31',      // Optional - ISO 8601 date
});

const updated = await pf.discounts.update('discount_id', {
  value: 25,
  active: true,
});

await pf.discounts.delete('discount_id');

const { upsells, salesWithUpsells } = await pf.upsells.list();

const upsell = await pf.upsells.get('upsell_id');

const upsell = await pf.upsells.create({
  mainProductIds: ['product_id'],      // Required - products that trigger this upsell
  upsellProductId: 'premium_product_id', // Required - product to upsell
  upsellPrice: 49.99,                  // Required - upsell price
  name: 'Premium Upgrade',             // Optional
  offer: 'Special one-time offer!',    // Optional - headline text
  upsellDescription: 'Upgrade to premium!', // Optional
  primaryButtonText: 'Yes, upgrade me!',    // Optional
  secondaryButtonText: 'No thanks',         // Optional
  active: true,                        // Optional (default: true)
});

const updated = await pf.upsells.update('upsell_id', {
  upsellPrice: 39.99,
  active: true,
});

await pf.upsells.delete('upsell_id');

const subscriptions = await pf.subscriptions.list({
  page: 1,
  pageSize: 20,
  startDate: '2024-01-01',
  endDate: '2024-12-31',
});

const subscription = await pf.subscriptions.get('subscription_id');

await pf.subscriptions.cancel('subscription_id');

await pf.subscriptions.refund('subscription_id');

const webhooks = await pf.webhooks.list();

const webhook = await pf.webhooks.get('webhook_id');

const webhook = await pf.webhooks.create({
  url: 'https://your-server.com/webhook', // Required
  events: ['order.completed', 'order.refunded'], // Required
  description: 'My webhook endpoint',     // Optional
  active: true,                           // Optional (default: true)
});

const updated = await pf.webhooks.update('webhook_id', {
  events: ['order.created', 'order.refunded', 'subscription.created'],
  active: true,
});

await pf.webhooks.test('webhook_id');

await pf.webhooks.delete('webhook_id');

const user = await pf.users.me();

console.log(user.email);
console.log(user.subdomain); // Your store subdomain

const updated = await pf.users.update({
  firstName: 'John',
  lastName: 'Doe',
  currency: 'USD',
  country: 'US',
});

const session = await pf.checkout.create({
  productId: 'product_id',
  successUrl: 'https://your-site.com/success',
  cancelUrl: 'https://your-site.com/cancel',
  customerEmail: 'customer@example.com', // optional
  discountCode: 'SUMMER20', // optional
  metadata: { orderId: '12345' }, // optional
});

// Redirect customer to checkout
console.log(session.url);

const refunds = await pf.refunds.list();

const refund = await pf.refunds.get('refund_id');

const refund = await pf.refunds.create({
  orderId: 'order_id',
  amount: 29.99, // optional, defaults to full refund
  reason: 'Customer requested refund',
});

import { Pocketsflow, PocketsflowError } from 'pocketsflow';

try {
  const product = await pf.products.get('invalid_id');
} catch (error) {
  if (error instanceof PocketsflowError) {
    console.error('API Error:', error.message);
    console.error('Status:', error.status); // HTTP status code
    console.error('Code:', error.code); // Error code if available
  }
}

import {
  Pocketsflow,
  Product,
  Order,
  Customer,
  CreateProductParams,
  PocketsflowError,
} from 'pocketsflow';

// All types are available
const params: CreateProductParams = {
  name: 'My Product',
  price: 29.99,
  currency: 'USD',
};

const product: Product = await pf.products.create(params);