Tagada Rx with the Node SDK

The Node SDK exposes the whole merchant-side Rx surface under tagada.rx.*. Use it from your backend, ops scripts, or partner provisioning flows — anywhere you hold a Tagada API key.

npm install @tagadapay/node-sdk

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

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

The Node SDK maps 1:1 onto the REST endpoints under /api/v1/rx/*, so everything here is also available as plain HTTP with Authorization: Bearer <key>.

Setup & configuration

// 1. Activate the integration (creates the pending setup-fee state)
await tagada.rx.requestActivation({
  storeId: 'store_xxx',
  clinicalNetworkSlug: 'mdi',
  operatingMode: 'affiliate',   // or 'direct' — see Operating modes
});

// 2. After the setup fee is captured (billing does this in prod;
//    admins can force it in sandbox):
await tagada.rx.confirmSetupFeePaid({ storeId: 'store_xxx' });

// 3. Wire the clinical-network credentials for your brand
await tagada.rx.configureBrandClinical({
  storeId: 'store_xxx',
  credentials: {
    clientId: '…',
    clientSecret: '…',
    webhookSecret: '…',
    externalEnvironmentId: '…',
  },
});

// 4. Map products to network offerings ("this product requires Rx")
await tagada.rx.setProductOffering({
  storeId: 'store_xxx',
  productId: 'product_xxx',
  externalOfferingId: '<network offering UUID>',
  requiresIdVerification: true,
});

Check where you stand at any point:

const status = await tagada.rx.integrationStatus('store_xxx');
// { state: 'not_requested' | 'pending_payment' | 'active', ... }

const networks = await tagada.rx.listNetworks();
const brand = await tagada.rx.getBrandConfig('store_xxx');

// Steps, missing items and whether Rx payments are ready
const activation = await tagada.rx.activationStatus('store_xxx');
// { state: 'active', payments: 'setting_up' | 'ready',
//   missing: ['payout_kyc', 'statement_descriptor', ...], steps: [...] }

Statement descriptor

In affiliate mode Tagada is the merchant of record, so the cardholder line is TGDCARE*<BRAND>. The brand chooses <BRAND> (A-Z, 0-9 and spaces, 14 characters max; accents are folded, other characters dropped) and Tagada reviews it. Until it is approved, statements show a line built from the store name.

await tagada.rx.setStatementDescriptor({ storeId: 'store_xxx', descriptor: 'Prime Rx' });
const d = await tagada.rx.getStatementDescriptor('store_xxx');
// { descriptor: 'PRIME RX', status: 'pending', preview: 'TGDCARE*PRIME RX', ... }

A rejected descriptor comes back with status: 'rejected' and a rejectionReason; submit a new one.

Working with cases

// List cases for a store (filterable, paginated)
const { cases } = await tagada.rx.cases.list({ storeId: 'store_xxx' });

// One case + its full append-only event timeline
const detail = await tagada.rx.cases.retrieve('rxcase_xxx');
detail.events.forEach((e) => {
  console.log(e.eventType, e.statusAfter, e.postedAt);
  // case.submitted  submitted   2026-07-16T22:01:11Z
  // case.in_review  in_review   2026-07-16T22:16:31Z
  // case.approved   approved    2026-07-16T23:02:05Z
  // shipment.shipped shipped    2026-07-17T14:30:00Z
});

You can also submit cases server-side (e.g. from a custom backend that already collected the intake) — but remember the PHI rule: pass it through, never store it:

const result = await tagada.rx.cases.submit({
  orderId: 'order_xxx',
  productId: 'product_xxx',
  patient: { /* US address in the 50 states or DC, US phone, 5 digit ZIP, adult */ },
  // One answer per question of the network questionnaire the patient saw,
  // keyed by the question title (see questions-for-product).
  intakeAnswers: [
    { questionId: 'Do you have any drug allergies or intolerances?', value: 'No - No known drug allergies' },
    // …
  ],
});

The same rules apply as from the browser: a patient or intake that does not meet the clinical network rules fails with 422 and the list of fields to fix, and nothing reaches the clinician. Check first with POST /api/public/v1/rx/intake/validate (see Headless SDK); the headless SDK helpers isQuestionActive and toIntakeAnswers also run on Node.

Refills

Refills normally run themselves (ship-day rebill engine, see How it works). Trigger one manually when support needs it:

await tagada.rx.cases.requestRefill({ caseId: 'rxcase_xxx' });

Only cases in shipped or delivered are refill-eligible.

Affiliate terms (MoR mode)

// Read the active commission terms (rides along the brand config)
const brand = await tagada.rx.getBrandConfig('store_xxx');

// Setting terms is account-manager-restricted:
await tagada.rx.setAffiliateTerms({
  storeId: 'store_xxx',
  basis: 'order_subtotal_bps',   // or 'order_net_bps' | 'flat_per_case_minor'
  value: 1500,                   // 15%
});

Accruals post automatically at case submission and reverse automatically on clinician decline — there is nothing to call.

Install the storefront Funnel v2

tagada.rx.* is the clinical surface. The canvas operators see in the CRM is a regular Funnel v2. After you activate Rx (or when you seed a headless store), create the same six-step graph the hosted templates get on publish:

await tagada.funnels.create({
  storeId,
  isDefault: true,
  config: { id: 'rx-storefront', name: `${brandName} storefront`, /* nodes + edges */ },
});

Copy the full graph from With the Headless SDK or run the rx-storefront example (pnpm seed calls funnels.create and writes funnel.bundle.json for Funnels → Import bundle).

Method reference

Method	What it does
`tagada.rx.requestActivation(input)`	Start activation (creates pending setup fee)
`tagada.rx.confirmSetupFeePaid(input)`	Flip to active after the fee is captured
`tagada.rx.configureBrandClinical(input)`	Wire clinical-network credentials
`tagada.rx.integrationStatus(storeId)`	`not_requested` / `pending_payment` / `active`
`tagada.rx.activationStatus(storeId)`	Steps, missing items, `payments: 'setting_up' \| 'ready'` (3.24.0+)
`tagada.rx.getStatementDescriptor(storeId)`	Brand statement descriptor + review state (3.24.0+)
`tagada.rx.setStatementDescriptor(input)`	Submit the brand descriptor for Tagada review (3.24.0+)
`tagada.rx.listNetworks()`	Clinical networks available to the account
`tagada.rx.getBrandConfig(storeId)`	Brand clinical config + terms
`tagada.rx.setAffiliateTerms(input)`	Version new commission terms (AM only)
`tagada.rx.setProductOffering(input)`	Map product ↔ network offering
`tagada.rx.cases.list(params)`	List cases
`tagada.rx.cases.retrieve(caseId)`	Case + event timeline
`tagada.rx.cases.submit(input)`	Submit a case (PHI pass-through)
`tagada.rx.cases.requestRefill(input)`	Manual refill trigger

Get Started

Activate

Build

Patients

Partners

Reference

With the Node SDK

Tagada Rx with the Node SDK

Setup & configuration

Statement descriptor

Working with cases

Refills

Affiliate terms (MoR mode)

Install the storefront Funnel v2

Method reference

​Tagada Rx with the Node SDK

​Setup & configuration

​Statement descriptor

​Working with cases

​Refills

​Affiliate terms (MoR mode)

​Install the storefront Funnel v2

​Method reference

Tagada Rx with the Node SDK

Setup & configuration

Statement descriptor

Working with cases

Refills

Affiliate terms (MoR mode)

Install the storefront Funnel v2

Method reference