Build a Telehealth Site with Decoda

This guide shows how to use Decoda as the EMR and billing engine behind your own telehealth front end. Your site owns the patient experience — booking, video, branding — and Decoda holds the chart, the note, and the money. The end-to-end flow is:

Create the patient record from your sign-up form.

Collect the intake form

Submit the patient’s form answers. Mapped answers flow straight into the chart.

Draft the clinical note

Pre-fill a note from the intake answers and same-day measurements, then create it for the provider to finish.

Build an itemized charge

List your catalog items to get their IDs, then create a charge with line items and discounts.

Take payment

Collect payment through the embedded payment component — either charge now at checkout, or charge a card already on file.

(Optional) Enroll in a membership

Turn the visit into recurring revenue by enrolling the patient in a membership billed to their saved card.

Conventions used throughout this guide

All amounts are in cents (10000 = $100.00).
Request bodies are camelCase JSON (patientId, totalOutstanding).
Every request needs the TENANT and API-KEY headers. Keep your API key server-side — never ship it to the browser. See the Quick Start for credentials.

Prerequisites

Set these up once in the console before you write any integration code. They’re the templates and catalog your API calls reference by ID.

Prerequisite	Where	Why you need it
Form template	Form Editor	Defines the intake questions and which answers map to the chart. Referenced by `formId`.
Note template	Manual notes — or generate one from a form (below)	Defines the clinical note layout the provider fills in. Referenced by `templateId`.
Catalog items	Items settings	Products, services, and fees you bill. Referenced by `itemId` on charge line items.
Memberships	Memberships settings	Recurring plans patients can enroll in. Referenced by `membershipId`.
A merchant account	Billing settings	Where payments land. Payments fail without one.

Generate a note template from a form so the note mirrors the intake you already built. Call Create Note Template From Form with the formId:

curl -X POST "https://api.decodahealth.com/notes/templates/from-form/form_xxx" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{ "name": "Telehealth Visit Note" }'

template = requests.post(
    f"{BASE_URL}/notes/templates/from-form/{form_id}",
    headers=headers,
    json={"name": "Telehealth Visit Note"},
).json()
template_id = template["id"]

const template = await ky.post(
  `${BASE_URL}/notes/templates/from-form/${formId}`,
  { headers, json: { name: "Telehealth Visit Note" } },
).json<any>();
const templateId = template.id;

The conversion flattens the form’s blocks and questions into note fields. Signature, payment, disclaimer, statement, and document questions are skipped.

Every code sample below assumes this shared setup:

import requests

BASE_URL = "https://api.decodahealth.com"
headers = {
    "API-KEY": "YOUR_API_KEY",
    "TENANT": "YOUR_TENANT",
    "Content-Type": "application/json",
}

import ky from "ky";

const BASE_URL = "https://api.decodahealth.com";
const headers = { "API-KEY": "YOUR_API_KEY", TENANT: "YOUR_TENANT" };

Step 1: Register the patient

When someone signs up on your site, create their Decoda patient record with Create Patient. Pass an externalId to link the record back to your own user table.

curl -X POST "https://api.decodahealth.com/user/patient/create" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{
       "firstName": "Jane",
       "lastName": "Smith",
       "email": "jane.smith@example.com",
       "phoneNumber": "+14155550100",
       "dateOfBirth": "1990-01-15",
       "externalId": "your_user_12345",
       "patientSource": "WEB_FORM"
     }'

patient = requests.post(
    f"{BASE_URL}/user/patient/create",
    headers=headers,
    json={
        "firstName": "Jane",
        "lastName": "Smith",
        "email": "jane.smith@example.com",
        "phoneNumber": "+14155550100",
        "dateOfBirth": "1990-01-15",
        "externalId": "your_user_12345",
        "patientSource": "WEB_FORM",
    },
).json()
patient_id = patient["id"]

const patient = await ky.post(`${BASE_URL}/user/patient/create`, {
  headers,
  json: {
    firstName: "Jane",
    lastName: "Smith",
    email: "jane.smith@example.com",
    phoneNumber: "+14155550100",
    dateOfBirth: "1990-01-15",
    externalId: "your_user_12345",
    patientSource: "WEB_FORM",
  },
}).json<any>();
const patientId = patient.id;

Response (abbreviated):

{
  "id": "pat_1234567890",
  "firstName": "Jane",
  "lastName": "Smith",
  "email": "jane.smith@example.com",
  "externalId": "your_user_12345",
  "type": "PATIENT",
  "createdDate": "2026-07-29T10:00:00Z"
}

Save the returned id (pat_…) — every later step is keyed to it. Setting patientSource (e.g. WEB_FORM, SELF_SCHEDULING) tags how the patient reached you, which is useful for acquisition reporting.

Step 2: Collect the intake form

Your site renders the intake questions (or embeds the Decoda form), then submits the patient’s answers with Submit Form. Each entry in blocks carries a blockType (DEMOGRAPHICS, MEDICAL_HISTORY, PAYMENT_METHODS, INSURANCE, or DYNAMIC). Set isCompleteSubmission to true for a finished submission. Answers mapped to patient-record fields (demographics, medical history, measurements) save to the chart automatically — that’s what makes the note pre-fill work in Step 3.

curl -X PUT "https://api.decodahealth.com/forms/form_xxx/submit" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{
       "patientId": "pat_1234567890",
       "isCompleteSubmission": true,
       "blocks": [
         {
           "blockType": "DEMOGRAPHICS",
           "answers": { "weight": 165, "height": 68 }
         },
         {
           "blockType": "MEDICAL_HISTORY",
           "answers": { "allergies": ["Penicillin"] }
         }
       ]
     }'

requests.put(
    f"{BASE_URL}/forms/{form_id}/submit",
    headers=headers,
    json={
        "patientId": patient_id,
        "isCompleteSubmission": True,
        "blocks": [
            {"blockType": "DEMOGRAPHICS", "answers": {"weight": 165, "height": 68}},
            {"blockType": "MEDICAL_HISTORY", "answers": {"allergies": ["Penicillin"]}},
        ],
    },
)

await ky.put(`${BASE_URL}/forms/${formId}/submit`, {
  headers,
  json: {
    patientId,
    isCompleteSubmission: true,
    blocks: [
      { blockType: "DEMOGRAPHICS", answers: { weight: 165, height: 68 } },
      { blockType: "MEDICAL_HISTORY", answers: { allergies: ["Penicillin"] } },
    ],
  },
});

The exact answers shape per block comes from your form’s structure — see the Form Structure Reference. You can also let Decoda send the form to the patient by email/SMS instead of rendering it yourself; see Sending Forms.

Want a card on file? Add a Payment Methods block to the form, or capture the card separately with the Store Details embed. Either way you get back a paymentMethodId (pm_…) — you’ll need it for the saved-card payment path (Step 5, Option B) and for memberships (Step 6).

Step 3: Draft the pre-filled clinical note

Fetch the patient’s pre-filled answers for the template with Get Prefilled Answers, then pass them straight into Create Note. The prefill response returns each answer keyed by questionId, in the exact shape answers expects — so the provider opens a note that’s already partly filled from the intake.

# 1. Fetch pre-filled answers
curl -X GET "https://api.decodahealth.com/notes/templates/tpl_xxx/prefill/pat_1234567890" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT"

# 2. Create the note with those answers
curl -X POST "https://api.decodahealth.com/notes/create" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{
       "patientId": "pat_1234567890",
       "providerId": "prov_xxx",
       "title": "Telehealth Visit",
       "template": { "...": "the template object from your prereqs" },
       "answers": [
         { "questionId": "q_weight", "data": { "value": 165 } },
         { "questionId": "q_allergies", "data": { "values": ["Penicillin"] } }
       ]
     }'

prefill = requests.get(
    f"{BASE_URL}/notes/templates/{template_id}/prefill/{patient_id}",
    headers=headers,
).json()

answers = [
    {"questionId": a["questionId"], "data": a["data"]}
    for a in prefill["prefilledAnswers"]
]

note = requests.post(
    f"{BASE_URL}/notes/create",
    headers=headers,
    json={
        "patientId": patient_id,
        "providerId": "prov_xxx",
        "title": "Telehealth Visit",
        "template": template,   # the template object from your prereqs
        "answers": answers,
    },
).json()
note_id = note["id"]

const prefill = await ky.get(
  `${BASE_URL}/notes/templates/${templateId}/prefill/${patientId}`,
  { headers },
).json<any>();

const answers = prefill.prefilledAnswers.map((a: any) => ({
  questionId: a.questionId,
  data: a.data,
}));

const note = await ky.post(`${BASE_URL}/notes/create`, {
  headers,
  json: {
    patientId,
    providerId: "prov_xxx",
    title: "Telehealth Visit",
    template, // the template object from your prereqs
    answers,
  },
}).json<any>();

Prefill response:

{
  "templateId": "tpl_xxx",
  "patientId": "pat_1234567890",
  "prefilledAnswers": [
    { "questionId": "q_weight", "data": { "value": 165 }, "source": "Today's Measurement", "isUserReported": true },
    { "questionId": "q_allergies", "data": { "values": ["Penicillin"] }, "source": "Patient Record", "isUserReported": true }
  ]
}

Only questions mapped to the patient chart (demographics, medical history, and same-day measurements) come back pre-filled. Weight and height only pre-fill when a measurement was recorded the same day. Free-text questions come back empty — the provider fills those in the note, or you can auto-draft them with the AI Scribe. See Telehealth Visits for the provider-side experience.

Step 4: Build an itemized charge

A charge is what the patient owes for the visit. Line items reference your catalog items by itemId, so first list your items to grab their IDs, then create the charge.

List items to find their IDs

Use List Items (paginated) or Search Items to find the itemId and current price for what you’re billing.

curl -X GET "https://api.decodahealth.com/inventory/items/list?name=Consultation&per_page=20" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT"

items = requests.get(
    f"{BASE_URL}/inventory/items/list",
    headers=headers,
    params={"name": "Consultation", "per_page": 20},
).json()
consult = items["items"][0]  # -> {"id": "item_xxx", "name": "Consultation", "price": 10000, ...}

const items = await ky.get(`${BASE_URL}/inventory/items/list`, {
  headers,
  searchParams: { name: "Consultation", per_page: 20 },
}).json<any>();
const consult = items.items[0];

Don’t have the item yet? Create one once with Create Item ({ "name": "Consultation", "price": 10000 }) and reuse its id on every future charge.

Create the charge

Create the charge with Create Charge. Each line item takes itemId, name, quantity, price (cents), and an optional discounts array. Set totalOutstanding to the sum of the line items minus any discounts.

curl -X POST "https://api.decodahealth.com/billing/payment-terminal/charge/create" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{
       "patientId": "pat_1234567890",
       "totalOutstanding": 8500,
       "items": [
         {
           "itemId": "item_xxx",
           "name": "Consultation",
           "quantity": 1,
           "price": 10000,
           "discounts": [{ "amount": 1500, "order": 0, "quantity": 1 }]
         }
       ]
     }'

charge = requests.post(
    f"{BASE_URL}/billing/payment-terminal/charge/create",
    headers=headers,
    json={
        "patientId": patient_id,
        "totalOutstanding": 8500,
        "items": [
            {
                "itemId": consult["id"],
                "name": "Consultation",
                "quantity": 1,
                "price": 10000,
                "discounts": [{"amount": 1500, "order": 0, "quantity": 1}],
            }
        ],
    },
).json()
charge_id = charge["id"]

const charge = await ky.post(
  `${BASE_URL}/billing/payment-terminal/charge/create`,
  {
    headers,
    json: {
      patientId,
      totalOutstanding: 8500,
      items: [
        {
          itemId: consult.id,
          name: "Consultation",
          quantity: 1,
          price: 10000,
          discounts: [{ amount: 1500, order: 0, quantity: 1 }],
        },
      ],
    },
  },
).json<any>();
const chargeId = charge.id;

Discounts go in the discounts array (amount in cents, order 0-based, quantity), not a flat discountAmount field. totalOutstanding must equal item totals minus those discounts — here 10000 − 1500 = 8500. Applying discounts requires the BILLING_DISCOUNTS_APPLY permission on your API key.

Already building a cart elsewhere? Convert Cart to Charge carries a cart’s items and discounts onto a charge instead. See Payment Embed: Itemized Charges.

Step 5: Take payment

Collect payment through the embedded payment component. There are two avenues — pick per visit, or support both.

Option A — Charge now

Patient enters a card at checkout and pays immediately. Best for one-off visits and first-time patients.

Option B — Charge a card on file

You already stored the patient’s card (via the embed). Charge it server-side with no patient interaction. Best for follow-ups, no-show fees, and memberships.

Option A: Charge now (embedded checkout)

Point the embedded payment component at the charge. The embed shows the full itemized breakdown and applies the payment to the existing charge — no duplicate charge is created.

<iframe
  src="https://app.decodahealth.com/your-tenant/embed/pay/pat_1234567890?charge_id=chg_xxx&allowedMethods=CARD"
  width="100%"
  height="500"
  allow="payment"
  style="border: none; border-radius: 8px;"
></iframe>

Listen for the outcome via postMessage:

window.addEventListener('message', function (event) {
  if (event.data.type === 'payment_success') {
    // Payment applied to the charge
    console.log('Paid:', event.data.payinId);
  } else if (event.data.type === 'payment_failure') {
    console.log('Payment failed:', event.data.error);
  } else if (event.data.type === 'payment_loaded') {
    console.log('Payment form ready');
  }
});

The embed URL accepts allowedMethods (CARD, ACH, APPLE_PAY), theme (light / dark), and showSummary. See Payment Embed: Itemized Charges for the full parameter and event reference.

Option B: Charge a card already on file

If you saved a card earlier (a paymentMethodId, pm_…, from the Store Details embed or a form’s Payment Methods block), you can charge it from your server without any patient interaction. It’s a two-call sequence:

Create a pay-in config for the charge

Call Setup Payin Component with paymentMedium: "SAVED_PAYMENT_METHOD", the paymentMethodId, and the charge. It returns a payinConfigId.

Charge the saved card

Call Charge Payment Method with just the payinConfigId.

# 1. Create the pay-in config
curl -X POST "https://api.decodahealth.com/billing/payment-terminal/payin-config" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{
       "paymentMedium": "SAVED_PAYMENT_METHOD",
       "paymentMethodId": "pm_xxx",
       "charges": [
         { "id": "chg_xxx", "patientId": "pat_1234567890", "totalOutstanding": 8500 }
       ]
     }'
# -> { "payinConfigId": "pcfg_xxx", ... }

# 2. Charge the saved card
curl -X POST "https://api.decodahealth.com/billing/payment-terminal/charge-card/pm_xxx" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{ "payinConfigId": "pcfg_xxx" }'

# 1. Create the pay-in config for the saved card
payin = requests.post(
    f"{BASE_URL}/billing/payment-terminal/payin-config",
    headers=headers,
    json={
        "paymentMedium": "SAVED_PAYMENT_METHOD",
        "paymentMethodId": "pm_xxx",
        "charges": [
            {"id": charge_id, "patientId": patient_id, "totalOutstanding": 8500}
        ],
    },
).json()

# 2. Charge the card
result = requests.post(
    f"{BASE_URL}/billing/payment-terminal/charge-card/pm_xxx",
    headers=headers,
    json={"payinConfigId": payin["payinConfigId"]},
).json()

// 1. Create the pay-in config for the saved card
const payin = await ky.post(`${BASE_URL}/billing/payment-terminal/payin-config`, {
  headers,
  json: {
    paymentMedium: "SAVED_PAYMENT_METHOD",
    paymentMethodId: "pm_xxx",
    charges: [{ id: chargeId, patientId, totalOutstanding: 8500 }],
  },
}).json<any>();

// 2. Charge the card
const result = await ky.post(
  `${BASE_URL}/billing/payment-terminal/charge-card/pm_xxx`,
  { headers, json: { payinConfigId: payin.payinConfigId } },
).json<any>();

The charge-card response confirms the outcome:

{ "payinId": "payin_xxx", "amount": 8500, "status": "APPROVED", "authCode": "123456" }

The charge-card body is only { "payinConfigId": "…" }. Don’t send chargeId or amount there — those belong on the pay-in config. A missing payinConfigId usually surfaces from the processor as “Field is required.”

How do you get a paymentMethodId in the first place? The Store Details embed collects and saves a card without charging it, then hands you the pm_… id via postMessage or a redirect query param. That’s the “stored using the embedded payment component” step this whole option depends on.

Step 6: Enroll in a membership (recurring revenue)

Memberships turn a one-time patient into recurring revenue — a monthly or annual plan billed automatically to a card on file. This is where a telehealth business compounds: capture the card once, enroll, and Decoda bills every cycle.

Create the membership (once)

Define the plan with Create Membership, or build it in the console and reference its id. Key fields:

Field	Meaning
`name`	Plan name shown to the patient.
`price`	Recurring price in cents.
`billingFrequency`	`MONTHLY`, `YEARLY`, `QUARTERLY`, etc.
`benefitType`	What each cycle creates: `PREPAYMENT_DISCOUNT`, `PATIENT_CREDIT_GRANT`, or `NONE`.
`setupFee`	One-time fee charged at enrollment (cents).
`autoRenew`	Whether the plan renews automatically.

curl -X POST "https://api.decodahealth.com/inventory/memberships" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{
       "name": "Wellness Membership",
       "price": 9900,
       "billingFrequency": "MONTHLY",
       "benefitType": "PATIENT_CREDIT_GRANT",
       "patientCreditAmount": 9900,
       "setupFee": 0,
       "autoRenew": true
     }'

List existing plans anytime with List Memberships.

Enroll the patient

Enroll with Enroll Member (Deferred Billing), passing the saved paymentMethodId (from the Store Details embed in Step 5) and the firstBillingDate. Decoda bills that card on the first billing date and then every billingFrequency cycle.

curl -X POST "https://api.decodahealth.com/inventory/members/enroll-deferred" \
     -H "API-KEY: YOUR_API_KEY" \
     -H "TENANT: YOUR_TENANT" \
     -H "Content-Type: application/json" \
     -d '{
       "patientId": "pat_1234567890",
       "membershipId": "mem_xxx",
       "paymentMethodId": "pm_xxx",
       "startDate": "2026-07-29",
       "firstBillingDate": "2026-08-01",
       "soldByProviderId": "prov_xxx"
     }'

member = requests.post(
    f"{BASE_URL}/inventory/members/enroll-deferred",
    headers=headers,
    json={
        "patientId": patient_id,
        "membershipId": "mem_xxx",
        "paymentMethodId": "pm_xxx",
        "startDate": "2026-07-29",
        "firstBillingDate": "2026-08-01",
        "soldByProviderId": "prov_xxx",
    },
).json()

const member = await ky.post(`${BASE_URL}/inventory/members/enroll-deferred`, {
  headers,
  json: {
    patientId,
    membershipId: "mem_xxx",
    paymentMethodId: "pm_xxx",
    startDate: "2026-07-29",
    firstBillingDate: "2026-08-01",
    soldByProviderId: "prov_xxx",
  },
}).json<any>();

Need the patient to sign a membership agreement first? Use Enroll Member (Awaiting Form) instead — same body, but billing waits until the linked form is completed. To bill an existing member outside their regular cycle, use Manual Payment; to swap the card a member is billed on, use Update Payment Method.

End-to-end example

Here’s the one-time-visit path (Steps 1–5, Option A) tied together in Python. It assumes your form template, note template, and catalog item already exist.

import requests

BASE_URL = "https://api.decodahealth.com"
headers = {
    "API-KEY": "YOUR_API_KEY",
    "TENANT": "YOUR_TENANT",
    "Content-Type": "application/json",
}

FORM_ID = "form_xxx"
TEMPLATE_ID = "tpl_xxx"
PROVIDER_ID = "prov_xxx"


def run_telehealth_visit(signup, note_template):
    # 1. Register the patient
    patient = requests.post(
        f"{BASE_URL}/user/patient/create",
        headers=headers,
        json={**signup["patient"], "patientSource": "WEB_FORM"},
    ).json()
    pid = patient["id"]

    # 2. Submit the intake form (answers flow into the chart)
    requests.put(
        f"{BASE_URL}/forms/{FORM_ID}/submit",
        headers=headers,
        json={
            "patientId": pid,
            "isCompleteSubmission": True,
            "blocks": signup["intakeBlocks"],
        },
    )

    # 3. Draft the pre-filled note
    prefill = requests.get(
        f"{BASE_URL}/notes/templates/{TEMPLATE_ID}/prefill/{pid}",
        headers=headers,
    ).json()
    answers = [{"questionId": a["questionId"], "data": a["data"]}
               for a in prefill["prefilledAnswers"]]
    requests.post(
        f"{BASE_URL}/notes/create",
        headers=headers,
        json={
            "patientId": pid,
            "providerId": PROVIDER_ID,
            "title": "Telehealth Visit",
            "template": note_template,
            "answers": answers,
        },
    )

    # 4. Find the item, then build the charge
    consult = requests.get(
        f"{BASE_URL}/inventory/items/list",
        headers=headers,
        params={"name": "Consultation", "per_page": 1},
    ).json()["items"][0]

    charge = requests.post(
        f"{BASE_URL}/billing/payment-terminal/charge/create",
        headers=headers,
        json={
            "patientId": pid,
            "totalOutstanding": consult["price"],
            "items": [{
                "itemId": consult["id"],
                "name": consult["name"],
                "quantity": 1,
                "price": consult["price"],
            }],
        },
    ).json()

    # 5. Hand the charge to the embedded payment component (Option A)
    embed_url = (
        f"https://app.decodahealth.com/your-tenant/embed/pay/{pid}"
        f"?charge_id={charge['id']}&allowedMethods=CARD"
    )
    return {"patient_id": pid, "charge_id": charge["id"], "embed_url": embed_url}

Next steps

Webhook Events

Get notified when forms are submitted and payments succeed — instead of polling.

Store Details Embed

Save a card on file for the saved-card and membership flows.

Payment Embed: Itemized Charges

The embedded payment component and its parameters in depth.

Patient Onboarding

Add scheduling and appointment confirmations around this flow.

Getting Started

API Guides

Patient Management

Billing & Payments

Catalog & Inventory

Growth

Clinical & Scheduling

Communications

Platform

Build a Telehealth Site with Decoda

Build a Telehealth Site with Decoda

Prerequisites

Step 1: Register the patient

Step 2: Collect the intake form

Step 3: Draft the pre-filled clinical note

Step 4: Build an itemized charge

List items to find their IDs

Create the charge

Step 5: Take payment

Option A — Charge now

Option B — Charge a card on file

Option A: Charge now (embedded checkout)

Option B: Charge a card already on file

Step 6: Enroll in a membership (recurring revenue)

Create the membership (once)

Enroll the patient

End-to-end example

Next steps

Webhook Events

Store Details Embed

Payment Embed: Itemized Charges

Patient Onboarding

​Build a Telehealth Site with Decoda

​Prerequisites

​Step 1: Register the patient

​Step 2: Collect the intake form

​Step 3: Draft the pre-filled clinical note

​Step 4: Build an itemized charge

​List items to find their IDs

​Create the charge

​Step 5: Take payment

Option A — Charge now

Option B — Charge a card on file

​Option A: Charge now (embedded checkout)

​Option B: Charge a card already on file

​Step 6: Enroll in a membership (recurring revenue)

​Create the membership (once)

​Enroll the patient

​End-to-end example

​Next steps

Webhook Events

Store Details Embed

Payment Embed: Itemized Charges

Patient Onboarding

Build a Telehealth Site with Decoda

Prerequisites

Step 1: Register the patient

Step 2: Collect the intake form

Step 3: Draft the pre-filled clinical note

Step 4: Build an itemized charge

List items to find their IDs

Create the charge

Step 5: Take payment

Option A: Charge now (embedded checkout)

Option B: Charge a card already on file

Step 6: Enroll in a membership (recurring revenue)

Create the membership (once)

Enroll the patient

End-to-end example

Next steps