Customer

The customer module gives you access to customer profiles, order history, and subscriptions. Use it to build account dashboards, order tracking pages, and subscription management UIs.

Building a full account area — email-code login, subscription changes, cancellation with retention offers, addresses, cards? See Customer Portal.

Get Customer Profile

const customer = await tagada.customer.getProfile(customerId);

By Email

Not available. No route finds a customer by email from a storefront: the only email search needs a secret API key of the whole account, which must never ship to a browser. From 1.18.0, getByEmail() rejects with a TagadaError of code not_supported without sending a request (before, it always returned null). For the logged-in customer, use portal.getMe() or getProfile(customerId).

Update Email

const updated = await tagada.customer.updateProfile(customerId, {
  email: 'jane@example.com',
});

This is the checkout’s email step: only email is saved, other fields are ignored. To change the name and phone of a logged-in customer, use portal.updateProfile.

Orders

List Orders

const { orders, total } = await tagada.customer.getOrders(customerId, {
  limit: 10,
  offset: 0,
});

Newest first. It needs a session of that same customer: the checkout session, or a portal login. Another customer’s id rejects with TagadaNotFoundError. The route sends every order at once: limit and offset slice them in the SDK, and total counts them all. Works from 1.18.0; earlier versions called a route that does not exist.

Get Single Order

const order = await tagada.customer.getOrder(orderId);
// order.items            — line items on this order
// order.relatedOrders    — child orders from accepted upsells
//                          (metadata.mainOrderId === order.id)

Get an Order on the Thank-You Page

Accepted post-purchase offers create separate child orders, not extra lines on the main order — and they land asynchronously. The first fetch right after an accept usually misses them. Pass waitForRelatedOrders: true and the SDK polls for you:

const order = await tagada.customer.getOrder(orderId, {
  waitForRelatedOrders: true, // polls until relatedOrders is non-empty
  timeoutMs: 8000,            // optional, default 8000
  intervalMs: 2000,           // optional, default 2000
});

// Render one block per order:
const allOrders = [order, ...(order.relatedOrders ?? [])];

On timeout the latest snapshot is returned — it never throws. A customer who declined every offer simply gets an order with an empty relatedOrders after timeoutMs. In React, prefer the useOrder hook which renders the main order immediately and fills in the upsells in the background. Worked example: Basic post-purchase.

Subscriptions

List Subscriptions

const subscriptions = await tagada.customer.getSubscriptions(customerId);

The 20 most recent subscriptions of the logged-in customer. It needs the customer’s portal login; for any other customer id it returns [].

Get Single Subscription

const subscription = await tagada.customer.getSubscription(subscriptionId);

Looks the id up among those 20, and rejects with TagadaNotFoundError when it is not there. Both work from 1.18.0; earlier versions called routes that do not exist.

Manage a Subscription

await tagada.customer.skipSubscription(subscriptionId);
await tagada.customer.pauseSubscription(subscriptionId, { resumeAt: '2026-12-01' });
await tagada.customer.changeSubscriptionFrequency(subscriptionId, { optionId });
await tagada.customer.cancelSubscription(subscriptionId); // at the end of the paid period

Also resumeSubscription, rescheduleSubscription, updateSubscriptionQuantity, swapSubscriptionProduct and updateSubscriptionPaymentMethod. They act for the customer logged in with the emailed code, and each one can be turned off by the store. The full list, the permissions and the errors are on Customer Portal.

React Hook

import { useCustomer } from '@tagadapay/headless-sdk/react';

function CustomerDashboard({ customerId }: { customerId: string }) {
  const {
    customer,
    orders,
    subscriptions,
    isLoading,
    error,
    loadCustomer,
    loadOrders,
    loadSubscriptions,
    updateProfile,
  } = useCustomer(customerId); // auto-loads profile when customerId is provided

  useEffect(() => {
    if (customerId) {
      loadOrders(customerId);
      loadSubscriptions(customerId);
    }
  }, [customerId]);

  if (isLoading) return <p>Loading...</p>;
  if (error) return <p>Error: {error.message}</p>;

  return (
    <div>
      <h1>Welcome, {customer?.firstName}</h1>

      <h2>Orders</h2>
      {orders.map((order) => (
        <div key={order.id}>
          Order #{order.orderNumber} — {order.status}
        </div>
      ))}

      <h2>Subscriptions</h2>
      {subscriptions.map((sub) => (
        <div key={sub.id}>
          {sub.name} — {sub.status}
        </div>
      ))}
    </div>
  );
}

Full Hook API

Property / Method	Description
`customer`	Current customer profile (null until loaded)
`orders`	Array of customer orders
`subscriptions`	Array of customer subscriptions
`isLoading`	True during any async operation
`error`	Last error, if any
`loadCustomer(customerId)`	Load customer profile (called automatically if `customerId` is passed to the hook)
`loadOrders(customerId)`	Fetch all orders (needs that customer’s session)
`loadSubscriptions(customerId)`	Fetch all subscriptions
`updateProfile(customerId, data)`	Update the customer’s email (other fields are ignored)

`useOrder` — Thank-You Pages

useCustomer is for account dashboards (you have a customerId). On a thank-you page you have an orderId from the URL — use useOrder. It loads the order, renders it immediately, and keeps watching in the background for the child orders created by accepted upsells:

import { useOrder } from '@tagadapay/headless-sdk/react';

function ThankYouPage() {
  const orderId = new URLSearchParams(window.location.search).get('orderId');
  const { order, relatedOrders, isLoading, error } = useOrder(orderId);

  if (isLoading || !order) return <p>Loading your order…</p>;
  if (error) return <p>Error: {error.message}</p>;

  return (
    <div>
      <h1>Thank you!</h1>

      {/* Main order — the checkout purchase */}
      <OrderBlock title="Your order" order={order} />

      {/* One block per accepted upsell — appears automatically when it lands */}
      {relatedOrders.map((o) => (
        <OrderBlock key={o.id} title="Added to your order" order={o} />
      ))}
    </div>
  );
}

No manual polling: with the default watchRelatedOrders: true, the hook refetches every 2s for up to 8s while relatedOrders is empty, then stops. Upsell blocks pop in as soon as the child orders exist.

`useOrder` API

Property / Method	Description
`order`	The order (null until loaded)
`relatedOrders`	Child orders from accepted upsells (`[]` until they land)
`isLoading`	True during the initial fetch only
`error`	Last error, if any
`refresh()`	Refetch the order once

Option	Default	Description
`watchRelatedOrders`	`true`	Keep refetching while `relatedOrders` is empty
`watchTimeoutMs`	`8000`	How long to keep watching
`watchIntervalMs`	`2000`	Delay between refetches

Overview

Payments (V2)

Web Integration

Tracking & Attribution

Node SDK

Funnels

Funnel demos

Examples

Shopify

WooCommerce

SaaS Billing

Headless SDK

Plugin SDK

Plugin CLI

Tagada MCP (CRM V3)

Studio MCP (AI Agents)

Config MCP (AI Agents)

Hosting & A/B Testing

Internal

Customer

Customer

Get Customer Profile

By Email

Update Email

Orders

List Orders

Get Single Order

Get an Order on the Thank-You Page

Subscriptions

List Subscriptions

Get Single Subscription

Manage a Subscription

React Hook

Full Hook API

`useOrder` — Thank-You Pages

`useOrder` API

​Customer

​Get Customer Profile

​By Email

​Update Email

​Orders

​List Orders

​Get Single Order

​Get an Order on the Thank-You Page

​Subscriptions

​List Subscriptions

​Get Single Subscription

​Manage a Subscription

​React Hook

​Full Hook API

​useOrder — Thank-You Pages

​useOrder API

Customer

Get Customer Profile

By Email

Update Email

Orders

List Orders

Get Single Order

Get an Order on the Thank-You Page

Subscriptions

List Subscriptions

Get Single Subscription

Manage a Subscription

React Hook

Full Hook API

`useOrder` — Thank-You Pages

`useOrder` API