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

# Own prescribers and doctor-network access

> For clinics that use their own prescribers, the doctor network, or both (hybrid). Lists your own prescribers with the states each is licensed in, and says how the doctor network is used for your clinic. Read-only. Requires `patients:read` or `rx:read`.



## OpenAPI

````yaml /openapi.yaml get /prescribers
openapi: 3.1.0
info:
  title: VitaRelay API
  version: 2.0.0
  description: |
    The VitaRelay REST API.

    **Base URL:** `https://vitarelay.com/api/public/v1`

    ## Authentication
    All requests require a Bearer API key:

    ```text
    Authorization: Bearer vr_live_xxxxxxxxxxxxxxxx
    ```

    Keys are issued per organization. `vr_live_` keys act on production data.
    `vr_test_` keys operate a fully-isolated **sandbox** (see below).

    ## Pagination
    List endpoints are cursor-based. Pass `limit` (default 50, max 100) and
    `cursor` (the `next_cursor` from the previous page). When `next_cursor`
    is `null` there are no further pages. All resource ids are UUIDs.

    ## Idempotency
    Write endpoints accept your own external identifiers —
    `external_patient_id`, `external_intake_id`, `external_order_id`. These act
    as idempotency keys: replaying a request with the same external id returns
    the original resource (HTTP `200` instead of `201`) rather than creating a
    duplicate.

    ## Rate limiting
    Write endpoints are rate limited per API key — default **60 requests per
    minute** (fixed window). Exceeding the limit returns `429 rate_limited`
    with `Retry-After`, `X-RateLimit-Limit`, `X-RateLimit-Remaining` and
    `X-RateLimit-Reset` headers. Read endpoints are not rate limited in v1.

    ## Sandbox
    With a `vr_test_` key, writes never create real patients, intakes or orders
    and never charge a card. They return synthetic ids (`sandbox_pat_…`,
    `sandbox_int_…`, `sandbox_ord_…`) and include `"sandbox": true` in the
    response. Sandbox objects advance through a simulated lifecycle that fires
    real webhook deliveries to your endpoint (`intake.reviewed`, `order.paid` →
    `order.shipped` → `order.delivered`) with `"sandbox": true` in the payload.
    In sandbox, reference a patient by `external_patient_id` or by the returned
    `sandbox_pat_…` id.

    ## Webhooks
    Outbound webhooks are configured in the VitaRelay admin UI (there is no
    webhook management API). Events: `order.paid`, `order.shipped`,
    `order.delivered`, `order.exception`, `intake.reviewed`. Each delivery is
    signed with HMAC-SHA256 over the raw body and carries the headers
    `X-VitaRelay-Signature: sha256=<hex>`, `X-VitaRelay-Event`,
    `X-VitaRelay-Delivery` (event id) and `X-VitaRelay-Timestamp`. Failed
    deliveries are retried with exponential backoff and dead-lettered after the
    maximum attempts.
  contact:
    name: VitaRelay Support
    email: info@vitarelay.com
servers:
  - url: https://vitarelay.com/api/public/v1
    description: Production
security:
  - bearerAuth: []
tags:
  - name: Patients
    description: Patient records scoped to your organization.
  - name: Intakes
    description: >-
      The health questionnaire a prescriber reviews. There are two ways to
      complete one, and each has a Vita Clinic endpoint and a referral (Rx)
      endpoint. **Patient fills it in on our page:** `POST
      /patients/{patientId}/intake/send-link` (Vita Clinic) or `POST
      /rx/patients/{patientId}/intake` (referral). **You collect the answers and
      send them to us:** `POST /intakes` (Vita Clinic) or `POST
      /rx/patients/{patientId}/intake/submit` (referral). Check progress with
      `GET /patients/{patientId}/intake/status` and the `intake.submitted` /
      `intake.reviewed` webhooks. See [Intakes and prescriber
      review](/getting-started/intakes-and-prescriptions) and the [Intake
      answers reference](/getting-started/intake-responses).
  - name: Orders
    description: >-
      Orders and fulfillment status. Two billing modes: `card_on_file` (default)
      charges the clinic's stored card synchronously, and `patient_checkout`
      creates the order unpaid and returns a checkout block so the patient can
      pay on your own page via Authorize.Net Accept.js (see POST
      /orders/{id}/pay).
  - name: Products
    description: Catalog products available to your organization.
  - name: Prescriptions
    description: >-
      Prescriptions written by your organization (read only). Refer patients
      into the Internal Doctor Network (IDN). You refer; an IDN doctor evaluates
      and prescribes. Requires IDN activation and rx scopes.
  - name: Storefront
    description: >-
      Build and manage your clinic's patient storefront — settings, curated
      product listings and bundles. Requires the `shop:read` / `shop:write`
      scopes.
  - name: Subscriptions
    description: >-
      Patient-shop subscription lifecycle. Requires `subscriptions:read` or
      `subscriptions:write`.
paths:
  /prescribers:
    get:
      tags:
        - Patients
      summary: Own prescribers and doctor-network access
      description: >-
        For clinics that use their own prescribers, the doctor network, or both
        (hybrid). Lists your own prescribers with the states each is licensed
        in, and says how the doctor network is used for your clinic. Read-only.
        Requires `patients:read` or `rx:read`.
      responses:
        '200':
          description: Your prescribers and network access.
          content:
            application/json:
              schema:
                type: object
                properties:
                  data:
                    type: object
                    properties:
                      clinic_kind:
                        type: string
                        enum:
                          - practice
                          - hybrid
                          - tele_clinic
                      network_access:
                        type: string
                        enum:
                          - 'off'
                          - fallback
                          - always
                        description: >-
                          `off` never uses the doctor network, `fallback` only
                          where no own prescriber is licensed in the patient's
                          state, `always` for every patient.
                      own_prescribers:
                        type: array
                        items:
                          type: object
                          properties:
                            id:
                              type: string
                              format: uuid
                            name:
                              type: string
                              nullable: true
                            role:
                              type: string
                              nullable: true
                            states:
                              type: array
                              items:
                                type: string
                            can_prescribe_controlled:
                              type: boolean
                            on_duty:
                              type: boolean
                      doctor_network:
                        type: object
                        properties:
                          available:
                            type: boolean
                          used_for:
                            type: string
                            enum:
                              - every_patient
                              - states_no_own_prescriber_covers
                              - never
        '401':
          $ref: '#/components/responses/RxUnauthorized'
components:
  responses:
    RxUnauthorized:
      description: Missing/invalid key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/RxError'
  schemas:
    RxError:
      type: object
      properties:
        error:
          type: object
          properties:
            code:
              type: string
            message:
              type: string
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: |
        API key issued by VitaRelay. Send as `Authorization: Bearer vr_live_…`
        (production) or `Authorization: Bearer vr_test_…` (sandbox).

````

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