1. Onboard a sub-merchant     →  tpa_xxx + auto-created store
2. Mint a Processing 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_live_xxx (partner-scoped)

// One round-trip creates: a merchant (acc_xxx) + a TPA + a convenience store
const tpa = await partner.partners.processing.tpas.create({
  legalName: 'Acme SAS',       // required — the KYB legal entity
  country: 'FR',
  currency: 'EUR',
  externalRef: 'merchant_42',  // your own merchant id — used for idempotency
  // accountId: 'acc_xxx',    // pass this to attach to an EXISTING merchant
});

console.log(tpa.id);         // tpa_xxx — the sub-merchant TPA
console.log(tpa.accountId);  // acc_xxx — owning CRM merchant

// Discover the auto-created store via the CRM API
const stores = await partner.stores.list({ accountId: tpa.accountId });
const storeId = stores.data[0].id; // store_xxx

const key = await partner.partners.processing.tpas.keys.create(tpa.id);
// label: "Your Partner — merchant_42" (from externalRef)

console.log(key.secret);  // tp_sk_live_xxx — RETURNED ONCE, store securely
console.log(key.label);   // human-readable merchant id
console.log(key.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 PROCESSING KEY for this merchant
  const charging = new Tagada(process.env.MERCHANT_42_PROCESSING_KEY!);

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

  // Charge it
  const { payment } = await charging.payments.process({
    paymentInstrumentId: paymentInstrument.id,
    storeId: storeId,
    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.processing.tpas.create ────►│ provisions TPA + merchant
                                                                   ├─ stores tpa_xxx
                        partners.processing.tpas.keys.create ────►│ mints tp_sk_xxx
                                                                   │
tokenizeCard(card) ──► api.basistheory.com  ─────────────────────► │ vault stores PAN
       │                                                           │ returns tagadaToken
       │ tagadaToken                                                │
       ▼                                                            │
 POST /api/charge ──► createFromToken(tagadaToken)  ──► proc key ──►│ creates pi_xxx
                          │                                         │
                          ▼                                         │
                      payments.process(pi)            ──► proc key ─►│ routes to processor
                                                                    │ returns payment_xxx