> ## Documentation Index
> Fetch the complete documentation index at: https://openloop.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Known gaps and staging setup

> What is not available yet, what your staging tenant should contain, and how to tell "not seeded yet" from "broken" before you build.

Written for the engineer doing the integration. Everything here is something you would otherwise
discover by hitting it mid-build, so read it once before you start and again if something behaves
unexpectedly.

This page is only about **what is absent or environmental**. For how a working endpoint behaves,
see *API status*; for diagnosing a specific error, see *FAQ and troubleshooting*.

## Known gaps

| Area | Status today | Interim approach |
| - | - | - |
| **Order status** | Events only. There is no partner order read. Order status, payment status and tracking arrive as the prescription webhook events (by arrangement). | Give your OLH implementation contact the HTTPS endpoint that should receive the events; there is no self-serve registration. Delivery mechanics (signature, retries) are confirmed with your implementation contact when the endpoint is registered. See *Order status and tracking* and *Prescription events*. |
| **Matching webhook events to your patients** | Prescription, intake and charting events, among others, carry `data.emr_patient_id` (see [Correlating events to your records](https://openloop.mintlify.site/events.md#correlating-events-to-your-records)): your `/v0.1` patient id, the `id` that `GET /v0.1/patients/{id}` takes, whenever the id is known; it is omitted otherwise, never `null`. Without it, an event identifies the patient only by `data.patient_ref`, an opaque reference that is not guaranteed to be the `/v0.1` patient id, and carries no email; on prescription events `prescribed_product.code` is a product code, not a `/v0.1` product or price id. How a tenant whose patients exist only through `POST /v0.1/patients` correlates an event without `emr_patient_id` is not specified yet. | Key those events on `data.emr_patient_id` when it is present. For events without it, agree the correlation with your OLH implementation contact when the endpoint is registered, and do not build on a `patient_ref` mapping until it is confirmed for your tenant. |
| **Encounters** | Not a readable resource on the partner surface. The completed submit creates the encounter and returns `encounter_id` (verified on staging 2026-10-05); the questionnaire-response list filters by it (verified 2026-10-19; **staging only for now**, the filter is not in the production release yet) and the `intake.*` / `charting.*` events carry it. | Store `encounter_id` beside the questionnaire-response id; it is the key that brings the encounter note back. See [Encounter notes](https://openloop.mintlify.site/cookbook/encounter-notes.md). |
| **Charting events** | `charting.created` / `.signed` / `.completed` are delivered on staging only. They carry `encounter_id` (the id your intake submit returned) and form metadata, no answers. The note is readable with the `encounter_id` filter on the questionnaire-response list (filter verified on staging 2026-10-19). | Subscribe when your implementation contact enables it; read the note with `encounter_id=<data.encounter_id>&status=completed` and match `questionnaire_canonical` to the event's `questionnaire_ref`. See [Encounter notes](https://openloop.mintlify.site/cookbook/encounter-notes.md). |
| **Deletes** | Not available. Partners do not delete patients, questionnaire responses, consents or document references. | Keep test patients clearly synthetic and separate from real ones. Staging test data is cleaned up by OpenLoop — ask your OLH implementation contact. |
| **Questionnaire authoring** | OpenLoop-side. Questionnaires are authored by OpenLoop; you read them. | Read forms with `GET /v0.1/questionnaires` and `GET /v0.1/questionnaires/{id}`. Send content changes to your OLH implementation contact. |
| **Eligibility rules per tenant** | A completed `POST /v0.1/questionnaire-responses` on one staging tenant answers `502` ("eligibility rules are misconfigured") until its rules are re-seeded, while an in-progress submit answers `201` (verified on staging 2026-10-05). | If you see this `502`, it is environmental: report it with the `request_id` and ask for your tenant's rules to be re-seeded. Do not retry in a loop. |
| **Scheduling / appointments** | Published, and verified on staging in the week of 2026-10-05: appointment types, slots, reservations, `POST /v0.1/appointments` and `PATCH /v0.1/appointments/{id}` (both need an `Idempotency-Key`). Whether scheduling is enabled for your tenant in production is a tenant configuration. | Build against *Appointments and scheduling*. Confirm production enablement with your OLH implementation contact before you launch on it. |
| **Eligibility / insurance checks** | Endpoints appear in the reference; the partner tier is enabled on staging, with no committed production date. | Do not sequence a launch behind it. The contract is final, so you can build against it — but confirm enablement with your OLH implementation contact before you do. |
| **`programs`** | Program codes are platform vocabulary, but `/v0.1/programs` is not partner-reachable and nothing in this cookbook lists the codes that apply to you. | Learn the naming in *Programs and identifiers*, which also covers the identifier collision and how to find each program's questionnaire by title today. |
| **Catalogue and pharmacy readiness per program** | Products and prices are seeded by OpenLoop per program, and a program can have its intake before it has a catalogue. Whether the pharmacy side is ready to dispense for a program is a separate platform configuration, and it is **not readable by the partner** through the API. | Before building checkout for a program, read `GET /v0.1/products?active=true` and confirm the program's products are there. Pharmacy readiness per program is confirmed by OpenLoop in your tenant's readiness report — ask your OLH implementation contact for it rather than probing for it. |
| **Bloodwork / lab ordering** | `POST /v0.1/laboratories` exists and is write-only: there is no route to read a requisition back, and no lab booking. | Available by arrangement only. Raise it with your OLH implementation contact if it is in your scope; do not sequence a launch behind it. How to place an order once it is enabled: *Lab ordering*. |
| **Where your writes appear** | Everything you write is readable back on the API immediately, allowing for the read-back lag noted in *Retries and idempotency*. The tools your care team uses are fed from the platform on a per-tenant schedule: which record types flow, and how quickly, is a tenant configuration, and staging care-team tools may not be connected at all. | Verify through the API — the `201` and its read-back are the proof, see *Integration flow*. Ask your OLH implementation contact for your tenant's sync statement (which record types reach the care-team tools, and the expected delay) before you test against those tools. |
| **Allergies** | `/v0.1/allergy-intolerances` **does** exist and is easy to miss. Values are **free-text strings**, not enumerated, and there is no autocomplete. | Validate and normalise on your side if you need consistency. |
| **Version prefixes** | Your surface is `/v0.1` — every path in this cookbook, including `/v0.1/auth/token`. Paths under `/v1` on this host belong to internal services: a partner token draws an authorization error on some of them and an empty result set on others, never your tenant's data. | Take paths exactly as this cookbook and the reference give them. If a `/v1` path appears anywhere in your material, it is a mistake — report it. |
| **Reference document freshness** | The published reference can lag the running system. | If a documented endpoint returns `404` or a field behaves differently from the reference, report it with your `request_id` — it is more likely a documentation lag than a fault in your request. |

## Staging setup

**What is reachable.** Patients, questionnaires, questionnaire-responses, products, prices,
appointments, and configs all return `200` for a sandbox bearer token. Encounters and orders are
not on the partner surface.

**Everything is under `/v0.1`, including `/v0.1/auth/token`.** `/v1` paths are not part of the
partner surface — a partner token draws an authorization error on some and an empty result set on
others.

**Verify staging writes through the API, not through care-team tools.** A patient or intake you create on staging is proven by its `201` and its read-back. Whether it also appears in the tools your care team uses depends on your tenant's sync configuration, which may not be connected on staging at all.

**What is seeded is minimal, and it differs per tenant.** Do not calibrate against numbers in this
cookbook — run `GET /v0.1/questionnaires?limit=100` and `GET /v0.1/products?limit=100` and read
your own. Tenants we have seen hold a single generic seed questionnaire and a handful of
weight-management products.

**Establish which programs exist for you** by collecting the distinct `program_code` values across
your products. There is no "list my programs" call. If your programs are not in that set, nothing
relevant to you is seeded — request it, and expect that to be the most common reason a new
integration stalls in week one.

**Empty responses are usually missing seed data, not a broken query.** Confirm seeding before
debugging your request.

**A `403` about the `Authorization` header is usually a wrong-method error.** Before concluding an
endpoint is closed to you, check the reference for the verb that path accepts: `reservations`, `invoices/previews` and
`checkouts/sessions` all work on `POST` while returning that `403` on a `GET`. There is no partner `/prices` collection; read prices with
`GET /v0.1/products/{product_id}/prices` or `GET /v0.1/prices/{price_id}`.

**Lab ordering in staging runs against a sandbox lab network with a small cap on patients.** Each
patient you order for is registered with the lab network on their first order, and the staging
sandbox holds a limited number of them. Once it is full, a first order for a new patient fails with
a `502` `PROVIDER_ERROR` that is not caused by your request. If a correct request fails this way on
staging, report it with the `request_id` before changing your integration.

**Genuinely unavailable to partners:** `/v0.1/programs` and `/v0.1/bundles` — see the programs note
below.

**Query parameters some list endpoints require.** `/v0.1/subscriptions` and `/v0.1/invoices`
require `email`. Without them you get a `400` naming
the missing parameter.

> [!WARNING]
>
> **Developers outside the United States can be blocked by the WAF.** Authentication requests from
> some non-US regions are filtered at the edge before reaching the API, which presents as an auth
> failure rather than a geo block. If developers on your team are outside the US — or on a non-US
> VPN — send your OLH implementation contact the blocked request details and the source region so the
> traffic can be allow-listed. This is a one-time setup step per region and is easy to misdiagnose
> as a credential problem.

## Reporting a problem usefully

Include the `request_id` from the response envelope, the full path with its version prefix, and
the HTTP status. `request_id` is the fastest way for us to find the call server-side; a
description without one usually costs a round trip.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.