mkdir my-store && cd my-store
npm init -y
npm install @tagadapay/node-sdk @tagadapay/headless-sdk

import Tagada from '@tagadapay/node-sdk';

const tagada = new Tagada(process.env.TAGADA_API_KEY!);

// 1. Processor — connect Stripe (or use 'sandbox' for testing).
const { processor } = await tagada.processors.create({
  processor: {
    name: 'Stripe',
    type: 'stripe',
    enabled: true,
    supportedCurrencies: ['USD', 'EUR'],
    baseCurrency: 'USD',
    options: {
      secretKey: 'sk_test_...',
      publicKey: 'pk_test_...',
    },
  },
});

// 2. Payment flow — route transactions through that processor.
const flow = await tagada.paymentFlows.create({
  data: {
    name: 'Main Flow',
    strategy: 'simple',
    fallbackMode: false,
    maxFallbackRetries: 0,
    threeDsEnabled: false,
    stickyProcessorEnabled: false,
    pickProcessorStrategy: 'weighted',
    fallbackProcessorConfigs: [],
    processorConfigs: [
      { processorId: processor.id, weight: 100, disabled: false, nonStickable: false },
    ],
  },
});

// 3. Store
const store = await tagada.stores.create({
  name: 'My AI-Built Store',
  baseCurrency: 'USD',
  presentmentCurrencies: ['USD', 'EUR'],
  chargeCurrencies: ['USD'],
  selectedPaymentFlowId: flow.id,
});

// 4. Product
const tshirt = await tagada.products.create({
  storeId: store.id,
  name: 'Premium T-Shirt',
  description: 'Organic cotton, available in 3 colors',
  active: true,
  variants: [{
    name: 'Black / M',
    sku: 'tshirt-black-m',
    grams: 200,
    active: true,
    default: true,
    imageUrl: 'https://images.unsplash.com/photo-1521572163474-6864f9cf17ab?w=600&h=600&fit=crop',
    price: 3900,
    compareAtPrice: 4900,
    prices: [{
      currencyOptions: { USD: { amount: 3900 }, EUR: { amount: 3500 } },
      recurring: false,
      billingTiming: 'in_advance',
      default: true,
    }],
  }],
});

// That's it — no funnel needed. In a headless store your React app
// owns the routing (cart → checkout → thank-you), so the Tagada
// `funnels` resource (which exists for the no-code Studio runtime) is
// not required. The Headless SDK never reads it. See the
// "Why no funnel here?" accordion below if you're wondering when
// you would want one.

console.log(`Store ready: ${store.id}`);

npx tsx setup.ts

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

function ProductPage() {
  const { products, isLoading, loadProducts } = useCatalog();

  useEffect(() => { loadProducts(); }, [loadProducts]);

  return products.map(product => (
    <ProductCard key={product.id} product={product} />
  ));
}

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

const client = useHeadlessClient();

const { checkoutToken, sessionToken } = await client.checkout.createSession({
  items: cart.map(item => ({
    variantId: item.variantId,
    quantity: item.quantity,
  })),
  currency: 'USD',
});

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

const { session, updateCustomer, updateAddress, getShippingRates, applyPromo } =
  useCheckout(checkoutToken, sessionToken);

await updateCustomer({ email, firstName, lastName });
await updateAddress({ shippingAddress: { line1, city, state, postalCode, country } });
const rates = await getShippingRates();
await applyPromo('WELCOME10');

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

const { tokenizeCard, processPayment, isProcessing, loadPaymentSetup } = usePayment({
  onPaymentSuccess: (result) => router.push(`/thank-you?orderId=${result.order?.id}`),
  onPaymentFailed: (result) => toast.error(result.error),
});

useEffect(() => {
  if (session?.id) loadPaymentSetup(session.id);
}, [session?.id]);

const { tagadaToken } = await tokenizeCard({
  cardNumber: '4242424242424242',
  expiryDate: '12/28',
  cvc: '123',
  cardholderName: 'Jane Doe',
});

const result = await processPayment({
  checkoutSessionId: session.id,
  tagadaToken,
});

switch (result.status) {
  case 'succeeded':
    router.push(`/thank-you?orderId=${result.order?.id}`);
    break;
  case 'requires_redirect':
    // usePayment handles this automatically (redirects + resumes on return)
    break;
  case 'failed':
    toast.error(result.error);
    break;
}

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

const { listOffers, previewOffer, payPreviewedOffer } = useOffers();

const offers = await listOffers({ type: 'upsell' });

await previewOffer({ offerId: offers[0].id });
await payPreviewedOffer({
  offerId: offers[0].id,
  mainOrderId: paymentId,
});

import Tagada from '@tagadapay/node-sdk';

const tagada = new Tagada(process.env.TAGADA_API_KEY!);

await tagada.webhooks.create({
  storeId: 'store_xxx',
  url: 'https://my-store.com/api/webhooks/tagada',
  eventTypes: ['order/paid', 'subscription/created', 'order/refunded'],
});

// api/webhooks/tagada.ts (Next.js example)
export async function POST(req: Request) {
  const event = await req.json();

  switch (event.topic) {
    case 'order/paid':
      console.log('New order:', event.data.orderId);
      break;
    case 'subscription/created':
      console.log('New subscriber:', event.data.customerId);
      break;
  }

  return new Response('OK');
}

import Tagada from '@tagadapay/node-sdk';

const tagada = new Tagada(process.env.TAGADA_API_KEY!);

const result = await tagada.plugins.deployDirectory({
  directory: './dist',
  storeId: 'store_xxx',
  name: 'my-store',
});

console.log(`Live at: ${result.url}`);
// https://my-store--store_xxx.cdn.tagadapay.com/

npm run build
TAGADA_API_KEY=your-api-key npx tsx scripts/deploy.ts

import Tagada from '@tagadapay/node-sdk';

const tagada = new Tagada(process.env.TAGADA_API_KEY!);
const storeId = 'store_xxx';

const versionA = await tagada.plugins.deployDirectory({
  directory: './dist-a',
  storeId,
  name: 'my-store-a',
});

const versionB = await tagada.plugins.deployDirectory({
  directory: './dist-b',
  storeId,
  name: 'my-store-b',
});

const mountPoints = await tagada.plugins.listMountPoints(storeId);
const routeId = mountPoints.mountPoints[0]?.id as string;

await tagada.plugins.configureSplit({
  routeId,
  storeId,
  splitConfig: {
    type: 'weighted',
    instances: [
      { instanceId: versionA.instanceId, deploymentId: versionA.deploymentId, weight: 50 },
      { instanceId: versionB.instanceId, deploymentId: versionB.deploymentId, weight: 50 },
    ],
  },
});

const plugins = await tagada.plugins.list(storeId);
const instances = await tagada.plugins.listInstances(storeId);
const details = await tagada.plugins.retrieveDeployment(deploymentId);
await tagada.plugins.unmount({ deploymentId, storeId, hostname });
await tagada.plugins.del(pluginId, storeId);

fly launch && fly deploy