> ## 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.

# Not eligible

> How a clinician's decision surfaces today when a patient is not eligible, why no prescription event arrives, and how to message the patient without guessing.

A patient finishes your intake and then nothing arrives. This page is about that gap: where the
eligibility decision is actually made, why your integration sees an absence rather than a verdict,
and what to put in front of the patient when you cannot yet tell which absence you are looking at.

## What you'll do

**1. Submit the intake as usual**

`POST /v0.1/questionnaire-responses` returns `201` with the encounter id — and no verdict.

**2. Know what you can see**

The response you submitted (`GET /v0.1/questionnaire-responses/{id}`) and, by arrangement, the
prescription webhook events your endpoint receives. Encounters and orders are not readable.

**3. Read the absence correctly**

No prescription event is not a decision. It says nothing has been prescribed yet, not that a
clinician said no.

**4. Message from what you know**

Tell the patient their intake is with a clinician. Never render "not eligible" from an absence.

## Who decides, and when

Eligibility is a clinical decision. A clinician reviews the submitted intake and decides whether to
prescribe, after your submit call has returned, out of band from your integration.

So the shape of the flow is: your call is accepted, the decision happens later, and **the decision
itself is not a field you can read today**. Everything below is about working honestly inside that
constraint.

## What the intake submission gives you

`POST /v0.1/questionnaire-responses` with `status: "completed"` and a `subject` returns `201`. The
`data` object carries the response id, the questionnaire id, the subject, the answers as submitted,
`updated_at`, and `encounter_id` — the intake encounter the platform created for you.

It carries nothing that says eligible, not eligible, approved or declined. The check below asserts
the absence of four candidate field names — `eligibility`, `eligible`, `decision`, `outcome` — on
the submit response. The encounter it created is not readable on the partner surface, so there is no second place to
look.

> [!TIP]
>
> Locked by check `submit-returns-no-eligibility-verdict`: step `submit-carries-no-verdict` asserts
> the four absent names on the `201`, and step `reread-response` asserts the response reads back
> with the same ids.

## Recipe · Know what you can see for the patient

The partner surface gives you one read and one feed for this patient's progress:

1. **The response you submitted.** `GET /v0.1/questionnaire-responses/{id}` returns the answers and
   the `encounter_id` (verified on staging). `GET /v0.1/questionnaire-responses` also takes a
   `subject` filter in the published reference (published, not exercised by these checks).
2. **The prescription webhook events** your registered endpoint receives (by arrangement). The
   first one, `prescription.created`, arrives only after a clinician has prescribed.

That is all. Encounters and orders are not readable on the partner surface, so there is no
collection to poll for "has anything happened yet".

> [!TIP]
>
> The response read-back is step `reread-response` of check `submit-returns-no-eligibility-verdict`.

## Recipe · Tell one absence from another

The clinician's charting note is what triggers the medication order, and the first prescription
webhook event, `prescription.created`, fires from it — see *Integration flow*. That ordering is what
lets you locate a patient in the flow without ever seeing a verdict:

| What you can see | What it means |
| - | - |
| No `encounter_id` on the submit `201` | The intake did not land as a completed intake — it was submitted without `subject`, or with `status: "in-progress"`, both of which return `201` and create no encounter. See *Integration flow* |
| `encounter_id` returned, no prescription event yet | The intake landed, and no prescription has been written — **still under review, or not prescribed. These two look identical** |
| `prescription.created` received | A clinician prescribed. Follow *Order status and tracking* |
| `prescription.cancelled` received | The order was cancelled (`data.status` `cancelled`, `data.timestamps.cancelled_at`). It is not an eligibility verdict on the intake |

Row two is the whole point of this page. The decision is not a field on the response, and the first
artifact a decision produces — the `prescription.created` event — arrives only once a clinician has
prescribed. So a patient still awaiting review and a patient who will not be prescribed present
identically. Treat row two as "waiting", never as "declined".

> [!WARNING]
>
> **Key an event to your patient on `data.emr_patient_id` when the event carries it.** It is your
> `/v0.1` patient id, the `id` that `GET /v0.1/patients/{id}` takes, omitted when the id isn't known,
> never `null`. Without it, the event has only `data.patient_ref` — an opaque reference, not guaranteed
> to be the `/v0.1` patient id, with no email or phone to join on. If your patients exist only through
> `POST /v0.1/patients`, agree how such events correlate to them when the endpoint is registered (by
> arrangement).

> [!TIP]
>
> That the response carries no verdict is locked by check `submit-returns-no-eligibility-verdict`.
> Rows three and four rest on the prescription webhook events (by arrangement), which the conformance
> runner cannot exercise; see *Prescription events*.

## What comes back

Nothing here carries a verdict, so the table is what each field does tell you — and what it does
not.

| Field | Meaning | You key on it for |
| - | - | - |
| `data.id` (submit) | The questionnaire response id | Your own record of the application, and re-reading it later |
| `data.encounter_id` (submit) | The intake encounter the platform created; present only for a completed intake with `subject` | Telling "never landed" from "submitted and waiting", and escalation. Recoverable by re-reading the response. **It is not an outcome and not a readable resource** |
| `prescription.created` (event, by arrangement) | Sent only once a clinician has prescribed | The first artifact a decision produces — its absence is *waiting*, never *declined* |
| Billing events (`invoice.paid`, `subscription.*`) | Payment state is **not** on prescription events; it rides the `com.openloop.payments` events — see *Events* | Telling "prescribed, awaiting payment" from "paid". Also readable via `GET /v0.1/subscriptions` / `GET /v0.1/invoices` |
| `request_id` | Present on every response, success or failure | Escalating an intake that has sat too long |

No field named `eligibility`, `eligible`, `decision` or `outcome` appears on the submit
response — asserted by the check above.

## What to tell the patient

1. **Never derive a verdict from an absence.** No prescription event is exactly what you would
   see one second after submit.
2. **Say what is true:** the intake is with a clinician, and the patient will hear the outcome.
   Describe your own next step — an email, a status screen — rather than the platform's.
3. **Do not promise a review time** the API cannot confirm. Nothing in the response tells you how
   long a review takes, or whether one has started.
4. **Put a floor under the silence.** Age your own record of the submit: an intake with no
   `prescription.created` event after your chosen threshold is a case to escalate, not a case to
   tell the patient they were declined.
5. **Escalate with ids, not descriptions:** the `request_id` from the submit response, the patient
   id, and the `encounter_id`. Storing the response id and `encounter_id` together at submit is the
   cheap path, but the `encounter_id` is recoverable rather than lost: hold the response id and
   `GET /v0.1/questionnaire-responses/{id}` returns both.

> [!TIP]
>
> That the re-read recovers both ids is step `reread-response` of check
> `submit-returns-no-eligibility-verdict`.

## Gotchas

> [!WARNING]
>
> **A `201` on submit is acceptance of the form, not of the patient.** It is returned before any
> clinician has seen the intake. If your funnel shows a success screen here, word it as "submitted",
> never as "approved" or "eligible".

> [!WARNING]
>
> **Do not build a client-side eligibility gate and call it the platform's answer.** You may screen
> for your own reasons — a state you do not serve, an age range — but that is your rule, not a
> clinical decision, and a patient you turn away never reaches the clinician who could have reviewed
> them. Keep the two clearly separated in your copy and in your logs.

> [!NOTE]
>
> **Dated 2026-09-11 — expect this page to change.** A server-side eligibility verdict on submit is
> in development: the intake submission would evaluate `dob`, `state`, `sex` and `bmi`, and return a
> `400` when one of them is missing, so an ineligible patient is refused at submit rather than in
> silence. It is not on the partner surface today and nothing on this page anticipates it. Re-read
> this page before you build eligibility messaging if you are integrating after it ships.

> [!NOTE]
>
> **There is nothing to poll.** Orders and encounters are not partner-readable, so do not build a
> loop that waits for them. Wait for the prescription webhook events at your registered endpoint
> (by arrangement), and age your own record of the submit in the meantime.

## Related

> [card] [Integration flow](https://openloop.mintlify.site/cookbook/integration-flow.md)
>
> The happy path this interrupts: intake, the encounter id it returns, and what comes after

> [card] [Order status and tracking](https://openloop.mintlify.site/cookbook/order-status-and-tracking.md)
>
> Once a clinician prescribes, the prescription webhook events that follow the order


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