1. Onboard a sub-merchant     →  tpa_xxx, store_xxx auto-created
2. Mint a sub-key             →  tp_sk_xxx restricted to that tpa
3. Tokenize a card client-side→  tagadaToken (PCI-safe)
4. Charge                     →  payment_xxx ✓

npm install @tagadapay/node-sdk @tagadapay/core-js

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

const partner = new Tagada(process.env.TAGADA_PARTNER_KEY!);
//                          ↑ tp_sk_partner_live_xxx

// One round-trip creates: a stub `accounts` row + a store + a TPA
const tpa = await partner.partners.accounts.create({
  legalName: 'Acme SAS',
  country: 'FR',
  currency: 'EUR',
  externalRef: 'merchant_42',  // your own merchant id — used for idempotency
});

console.log(tpa.id);       // tpa_xxx — the sub-merchant
console.log(tpa.storeId);  // store_xxx — the auto-provisioned store
console.log(tpa.accountId);// acc_xxx — internal data-ownership anchor

const subKey = await partner.partners.apiKeys.create(tpa.id, {
  label: 'merchant_42 — server charges',
});

console.log(subKey.secret);  // tp_sk_live_xxx — RETURNED ONCE, store securely
console.log(subKey.id);      // ak_xxx — the key id (visible later for revocation)

<!-- Your merchant&rsquo;s checkout page -->
<form id="pay">
  <input id="card" placeholder="4242 4242 4242 4242" />
  <input id="exp"  placeholder="12/30" />
  <input id="cvc"  placeholder="123" />
  <button type="submit">Pay €49.99</button>
</form>

<script type="module">
  import { Tokenizer } from 'https://esm.sh/@tagadapay/core-js@2';

  const tokenizer = new Tokenizer({ environment: 'production' });

  document.getElementById('pay').addEventListener('submit', async (e) => {
    e.preventDefault();
    const tagadaToken = await tokenizer.tokenizeCard({
      cardNumber: card.value,
      expiryDate: exp.value,
      cvc: cvc.value,
    });

    // Send the token (and ONLY the token) to your server
    await fetch('/api/charge', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ tagadaToken, amount: 4999, currency: 'EUR' }),
    });
  });
</script>

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

// Your /api/charge handler
export async function POST(req: Request) {
  const { tagadaToken, amount, currency } = await req.json();

  // Re-create a Tagada client with the SUB-KEY for this merchant
  const charging = new Tagada(process.env.MERCHANT_42_SUBKEY!);

  // Create a reusable payment instrument from the single-use token
  const { paymentInstrument, customer } = await charging.paymentInstruments.createFromToken({
    tagadaToken,
    storeId: 'store_xxx',  // the storeId you got back from step 2
    customerData: {
      email: 'jane@example.com',
      firstName: 'Jane',
      lastName: 'Doe',
    },
  });

  // Charge it
  const { payment } = await charging.payments.process({
    paymentInstrumentId: paymentInstrument.id,
    storeId: 'store_xxx',
    amount,           // 4999 = €49.99 in minor units
    currency,         // 'EUR'
    paymentMethod: 'card',
    mode: 'purchase', // 'auth' for authorize-only, capture later
  });

  return Response.json({ paymentId: payment.id, status: payment.status });
}

Browser                          Your server                      TagadaPay
───────                          ───────────                      ─────────
                                                                   ┌─ partner key
                                       partners.accounts.create ──►│ provisions TPA + store
                                                                   ├─ stores tpa_xxx
                                       partners.apiKeys.create  ──►│ mints tp_sk_xxx
                                                                   │
tokenizeCard(card) ──► api.basistheory.com  ─────────────────────► │ vault stores PAN
       │                                                           │ returns tagadaToken
       │ tagadaToken                                                │
       ▼                                                            │
 POST /api/charge ──► createFromToken(tagadaToken)  ──► sub-key  ──►│ creates pi_xxx
                          │                                         │
                          ▼                                         │
                      payments.process(pi)            ──► sub-key ──►│ routes to processor
                                                                    │ returns payment_xxx