Provkeep for your stack

Where the check goes in the software you already run, and the few lines that make it. Your own code makes one call to Provkeep with the product and the states. Nothing about the patient is sent.

Provkeep is not an official partner of any platform on this page and holds no credential for any of them. Each name is used only to say which software a recipe is for.

The same on every recipe

What your code sends

  • Your own order or prescription reference
  • The product, and its dosage form
  • The two letter states: where it ships, and where the prescriber and pharmacy are
  • How the patient was seen (in person, video, phone or questionnaire) and what it is for, as codes

What Provkeep never receives

  • The patient's name, birth date, address, email or phone
  • The platform's own patient, case or chart ID
  • Any diagnosis or note about the patient
  • Any credential for the platform: Provkeep never connects to it

The answer quotes each rule with the agency, the link and the date we read it. It never says an order is allowed or not allowed: it is for your clinician or pharmacist to read. If Provkeep is slow or unreachable the kit answers checked: false and your flow carries on. The files are in the code kit; every field is in the API reference.

E-prescribing

Photon Health

For a team that prescribes through Photon and places orders from its own code.

Where the check goes

Between writing the prescription and placing its order. Photon places an order as a separate step, and your code makes that step.

Prescriptions written with Photon are not assigned or sent to a specific pharmacy until an Order is placed. This action can be completed programmatically.

Photon Health's documentation, Place orders, read 20 November 2026.

The code and the hold step are on the Photon page.

Their terms

Photon's Platform Terms of Service give access for users' own internal business purposes, keep the customer's data the customer's, and bar passing on content Photon supplies, such as pharmacy pricing. The check sends only your own order facts and nothing Photon supplies.

Customer retains all right, title, and interest in and to the Customer Data and Customer Material.

Photon Platform Terms of Service, last updated 10 September 2025, read 20 November 2026. This is what the page says, not legal advice; your own agreement with Photon Health governs.

Provkeep is not a Photon Health partner and holds no Photon Health credential. The full recipe

EHR

Healthie

For a clinic on Healthie whose account has API access. Healthie's docs say to ask them if you are not sure.

Where the check goes

Healthie sends e-prescriptions through DoseSpot, and its documentation names no point where your code runs between signing and sending. So the check goes earlier, in your own flow: when your code records the medication with createMedication, or when the intake form is signed (the form_answer_group.signed webhook). Show the answer to the prescriber before they open e-prescribing. It does not hold the DoseSpot send.

No GraphQL mutations trigger prescription updates directly. Prescriptions are updated through internal mechanisms or third-party integrations.

Healthie's documentation, Webhook event reference, read 20 November 2026.

The code

import { Provkeep, chartNote } from "./provkeep.mjs";   // the Node file from the code kit
const pk = new Provkeep(process.env.PROVKEEP_KEY);

// In your handler for form_answer_group.signed, or just before your own
// createMedication call. Order facts only: never Healthie's patient ID,
// the patient's name or birth date. code is your own reference.
const answer = await pk.check({
  code: myOrderRef,
  event: "order_created",
  patient_state: shipTo.state,
  prescriber_state: prescriber.state,
  consult_type: "video",               // in_person | video | phone | async_questionnaire
  purpose: "weight_management",        // a code, never words about the patient
  lines: [{ peptide: "semaglutide", dosage_form: "injectable" }],
}, { idempotencyKey: myOrderRef });

await showToPrescriber(chartNote(answer));   // yours: before they open e-prescribing

Their terms

Healthie's Terms of Use say a signed subscription agreement governs a paying clinic, and that agreement is not public. Its developer docs invite customers to build on the API. We found no public term requiring a partner agreement for a clinic's own integration; Healthie's marketplace agreement is for vendors listed in its marketplace.

Developer teams can use our API to build client-facing, and provider-facing, apps

Healthie API introduction, read 20 November 2026. This is what the page says, not legal advice; your own agreement with Healthie governs.

Provkeep is not a Healthie partner and holds no Healthie credential.

Pharmacy ordering API

Empower Pharmacy

For a clinic or platform that sends orders to Empower through Empower's API. Access comes from your Empower sales representative.

Where the check goes

Just before your code submits the order to Empower. Empower's Received webhook arrives after Empower has accepted the order, so it can record the check but cannot come before it.

The Received event is triggered when Empower Pharmacy successfully accepts an order submitted through the API.

Empower Pharmacy's documentation, Empower API introduction, read 20 November 2026.

The code

import { Provkeep, chartNote } from "./provkeep.mjs";   // the Node file from the code kit
const pk = new Provkeep(process.env.PROVKEEP_KEY);

const answer = await pk.check({
  code: myOrderRef,                     // the same reference you give Empower
  event: "order_created",
  patient_state: shipTo.state,
  prescriber_state: prescriber.state,
  pharmacy_state: pharmacy.state,       // where the dispensing pharmacy is
  consult_type: "video",
  lines: [{ peptide: "tirzepatide", dosage_form: "injectable" }],
}, { idempotencyKey: myOrderRef });

await showForReview(myOrderRef, chartNote(answer));   // yours
await submitEmpowerOrder();                           // yours: Empower's order call, as today

Their terms

Empower publishes no API terms. Its website terms bar passing content from its site to a third party; the check sends your own order facts, not Empower's content. Ask your Empower representative for the API terms before you build.

transmit or provide content from the Site to a third-party

Empower Terms of Use, read 20 November 2026. This is what the page says, not legal advice; your own agreement with Empower Pharmacy governs.

Provkeep is not a Empower Pharmacy partner and holds no Empower Pharmacy credential.

Pharmacy ordering API

Compounding Finder

For a practice or telehealth platform ordering through Compounding Finder's clinic API. Any practice can make a test key from its dashboard.

Where the check goes

After you pick the listing (GET /api/v1/medications with the patient's state) and before you place the order (POST /api/v1/orders). Use your externalOrderId as the Provkeep code.

Places a patient-specific order with one pharmacy.

Compounding Finder's documentation, Clinic API reference, read 20 November 2026.

The code

import { Provkeep, chartNote } from "./provkeep.mjs";   // the Node file from the code kit
const pk = new Provkeep(process.env.PROVKEEP_KEY);

// listing is the one you chose from GET /api/v1/medications.
const answer = await pk.check({
  code: externalOrderId,
  event: "order_created",
  patient_state: patientState,          // the same two letters you send them
  prescriber_state: prescriberState,
  pharmacy_state: listing.pharmacy.state,
  consult_type: "video",
  lines: [{ peptide: "BPC-157", dosage_form: listing.form }],
}, { idempotencyKey: externalOrderId });

await showForReview(externalOrderId, chartNote(answer));   // yours
await placeCompoundingFinderOrder();                       // yours: POST /api/v1/orders

Their terms

Compounding Finder's API terms are accepted in your clinic dashboard and are not public, so we have not read them; read them before you build. Its public pages offer the API for your own systems.

How do we connect our own system? Accept the API terms on the Developers page of your clinic dashboard, create a test key and follow the API reference.

Compounding Finder for clinics, read 20 November 2026. This is what the page says, not legal advice; your own agreement with Compounding Finder governs.

Provkeep is not a Compounding Finder partner and holds no Compounding Finder credential.

EHR

Cerbo

For a Cerbo practice whose own developer works with the Cerbo API. A Superadmin in the practice creates the API user.

Where the check goes

In the practice's own code, just before it posts the prescription. Cerbo publishes no event that fires before a prescription is sent, so this is the last point your code controls. Write the answer into the chart with your own Cerbo access.

Post a new patient prescription via the portal queue

Cerbo's documentation, Cerbo API documentation, read 20 November 2026.

The code

import { Provkeep, chartNote } from "./provkeep.mjs";   // the Node file from the code kit
const pk = new Provkeep(process.env.PROVKEEP_KEY);

// Your own product name, not Cerbo's drug record: Cerbo's drug list is
// licensed data for managing your own patients' medications.
const answer = await pk.check({
  code: prescription.orderNumber,
  event: "prescription_signed",
  patient_state: prescription.shipToState,
  prescriber_state: prescription.prescriberState,
  pharmacy_state: prescription.pharmacyState,
  consult_type: "video",
  purpose: "treatment",
  lines: [{ peptide: "testosterone", dosage_form: "injectable" }],
}, { idempotencyKey: prescription.orderNumber });

await writeCerboChartNote(chartNote(answer));   // yours, with your Cerbo access
await postCerboPrescription();                  // yours: POST /patients/{patient_id}/rxs

Their terms

Cerbo's Master Subscription Agreement makes the practice responsible for anything it sends to an outside service. Cerbo's drug list is licensed data that may only be used to manage your own patients' medications, so the check sends your own product name.

If Client requests that Client Materials be sent from the Services to Third-Party Service Providers or via Third-Party Applications (either programmatically/automatically or via data export), Client is solely responsible for transferred Client Material

Cerbo Master Subscription Agreement, last revised 30 October 2026, read 20 November 2026. This is what the page says, not legal advice; your own agreement with Cerbo governs.

Provkeep is not a Cerbo partner and holds no Cerbo credential.

E-prescribing, for software companies

DoseSpot

For an EHR or software company that built DoseSpot's Full Integration into its own screens. DoseSpot licenses its API to software companies, not to clinics directly.

Where the check goes

In your own code, before you call Send Prescriptions (/api/patients/{patientId}/prescriptions/send) or Set Prescriptions Ready To Sign. If you embed DoseSpot's own screen instead, the send happens inside it, so check before you open it, when your code adds the compound.

Full Integration allows you to ePrescribe within your native screens.

DoseSpot's documentation, DoseSpot Full Integration, read 20 November 2026.

The code

import { Provkeep, chartNote } from "./provkeep.mjs";   // the Node file from the code kit
const pk = new Provkeep(process.env.PROVKEEP_KEY);

// Before your Send Prescriptions call. Nothing of DoseSpot's is passed and
// Provkeep never reaches DoseSpot: your code sends your own order facts.
const answer = await pk.check({
  code: myOrderRef,
  event: "prescription_signed",
  patient_state: shipTo.state,
  prescriber_state: prescriber.state,
  pharmacy_state: pharmacy.state,
  consult_type: "video",
  lines: [{ peptide: "sermorelin", dosage_form: "injectable" }],
}, { idempotencyKey: myOrderRef });

await showToPrescriber(chartNote(answer));   // yours: on your own screen
await sendPrescriptions();                   // yours: DoseSpot's send, as today

Their terms

DoseSpot's Terms of Service bind the software company and limit who may use DoseSpot's technology. The check gives Provkeep no access to it and passes nothing of DoseSpot's.

Client will not provide access to the Licensed Technology to any person who is not an authorized employee, independent contractor of Client, or Prescriber End User

DoseSpot Terms of Service (Exhibit A), last updated 16 December 2025, read 20 November 2026. This is what the page says, not legal advice; your own agreement with DoseSpot governs.

Provkeep is not a DoseSpot partner and holds no DoseSpot credential.

White-label telehealth

OpenLoop

For a brand building on OpenLoop's API. Credentials come from your OpenLoop implementation contact.

Where the check goes

Before your code submits the completed intake (POST /v0.1/questionnaire-responses). OpenLoop's clinicians prescribe after that and a brand never creates the order, so the intake is the last point your code controls.

You never create an order, and you cannot read one.

OpenLoop's documentation, Integration flow, read 20 November 2026.

The code

import { Provkeep, chartNote } from "./provkeep.mjs";   // the Node file from the code kit
const pk = new Provkeep(process.env.PROVKEEP_KEY);

const answer = await pk.check({
  code: myIntakeRef,
  event: "order_created",
  patient_state: shipTo.state,
  consult_type: "async_questionnaire",
  purpose: "weight_management",
  lines: [{ peptide: "semaglutide", dosage_form: "injectable" }],
}, { idempotencyKey: myIntakeRef });

await showForReview(myIntakeRef, chartNote(answer));   // yours
await submitIntake();                                  // yours: OpenLoop's call, as today

Their terms

We found no public API or partner terms for OpenLoop: its terms of use page carried no text we could read. Your contract with OpenLoop governs; check it before you build.

Provkeep is not a OpenLoop partner and holds no OpenLoop credential.

White-label telehealth

MD Integrations

For a brand registered as an MD Integrations partner. Registration gives sandbox access.

Where the check goes

Between checking where the offering is available (GET /partner/offerings/{offering}/states) and creating the case (POST /partner/cases). Use your external_id as the Provkeep code.

Returns the list of states where the specified offering is available for the authenticated partner.

MD Integrations's documentation, MD Integrations partner documentation, read 20 November 2026.

The code

import { Provkeep, chartNote } from "./provkeep.mjs";   // the Node file from the code kit
const pk = new Provkeep(process.env.PROVKEEP_KEY);

const answer = await pk.check({
  code: externalId,
  event: "order_created",
  patient_state: shipTo.state,
  consult_type: "async_questionnaire",
  purpose: "weight_management",
  lines: [{ peptide: "tirzepatide", dosage_form: "injectable" }],
}, { idempotencyKey: externalId });

await showForReview(externalId, chartNote(answer));   // yours
await createCase();                                   // yours: POST /partner/cases, as today

Their terms

MD Integrations' website terms ask that nothing suggest an affiliation without its written permission. Provkeep has none: we are not affiliated with MD Integrations, and this page links only to the front of its documentation.

Suggests an express or implied affiliation or relationship with us without our express written permission

MD Integrations Terms of Service, last revised 2 May 2024, read 20 November 2026. This is what the page says, not legal advice; your own agreement with MD Integrations governs.

Provkeep is not a MD Integrations partner and holds no MD Integrations credential.

Store

WooCommerce®

For a store on WooCommerce. Provkeep for WooCommerce is our plugin, and it needs no code.

Where the check goes

The plugin checks each order after checkout and adds a note to it; it never blocks the checkout. If you write your own check, the classic checkout's woocommerce_after_checkout_validation hook runs before the order is placed. The block checkout has no such hook outside payment methods.

Custom field validation using hooks such as woocommerce_checkout_process: Supported by hooking into the payment processing events

WooCommerce®'s documentation, Hook alternatives, read 20 November 2026.

Install the plugin and paste the one time code from Settings. How it works is on the developers page.

Their terms

WooCommerce's trademark guidelines allow a product to say it is for WooCommerce, with its own name first, and ask that nothing suggest Automattic endorses it.

Use your distinctive product name immediately preceding the use of " compatible with WooCommerce" or " for WooCommerce."

WooCommerce trademark guidelines, read 20 November 2026. This is what the page says, not legal advice; your own agreement with WooCommerce® governs.

Provkeep is not a WooCommerce® partner and holds no WooCommerce® credential. The full recipe

WooCommerce and its associated designs are trademarks of Automattic Inc.

Platforms with no recipe

These publish no documentation we could read, or their terms do not allow it. Check the order on the Lookup screen in Provkeep and paste the text into the chart, or call the API from any system of your own that sits before the order.

  • OptiMantra. Publishes outbound webhooks for appointment, status and tag information. We found no published event for a signed prescription and no public API documentation, so use the Lookup screen in Provkeep and paste the text into the chart.
  • Elation. Its API License and Usage Agreement allows only the uses it lists and "prohibits use of the API for use cases not described above". Sending order facts to an outside service is not one of them, so we publish no recipe. Ask Elation first.
  • LifeFile. Publishes no partner program, documentation or price. Orders reach it through the pharmacies that run it; Empower publishes its own API, above.
  • CareValidate. Describes a REST API and sandbox, with documentation behind a demo.
  • Rimo, Beluga, Telegra, Wizlo and SteadyMD. Publish no developer documentation; partnership is by demo call.

Two more platforms we read require written permission to integrate with them or to use their name, so they are not named here.

Building software for many clinics? Each one can connect its own Provkeep account through Connect Provkeep.