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

# List Patient Eligibility Links

> Lists all eligibility requests linked with a specific patient



## OpenAPI

````yaml GET /api/auth/v1/patients/{patient_code}/eligibility/
openapi: 3.0.2
info:
  title: Anagram backend
  version: 1.0.0
servers:
  - url: https://api.anagram.care
    description: Authenticated API
security:
  - ApiToken: []
tags:
  - name: public-auth_Eligibility Request
    x-displayName: Eligibility Request
    description: >-
      Requesting patient's eligibility uses the following parameters:


      - First name (required)

      - Last name (required)

      - Date of birth (required)

      - Last four digits from SSN (optional)

      - Zip code (required)

      - Insurer Member ID (optional)

      - Request UID (optional)


      This call is asynchronous, it initiates an eligibility search and returns
      a UID assigned to this request.

      The result will be returned in two ways:

      - Via active [webhooks](https://provider.anagram.care/webhooks) once
      available - preferred.

      Request UID will be included in payload.

      - By calling the "Eligibility Result" endpoint - only to be used as
      fallback. Request UID is required.


      If specifying a UID, ensure it is unique. If omitted one will be generated
      automatically

      and included in the response for this API call.


      Authentication is required for this endpoint. Access token can be obtained

      in [provider app](https://provider.anagram.care/). Access token must be
      sent in `Authorization` header,

      prefaced with `API `:


      `Authorization: Api <key generated in provider app>`


      The response will contain the request UID or a validation error.


      Error examples:

      ```

      {
          "errors": {"$": ["Wrong insurer code"]}
      }

      ```

      ```

      {
          "errors": {
              "patient": {
                  "first_name": {"$": ["This field cannot be blank."]}
              }
          }
      }

      ```


      For testing purposes, you can include cheat codes in the request. Cheat
      codes can be provided in the fields

      `first_name`, `last_name`, and `member_id`. Here are some examples of
      cheat codes:


      - `mark_used`: This cheat code marks all benefits as used.


      - `dt_exam_used`: This cheat code marks exam benefit as used.


      - `no_oon`: Removes all out-of-network benefits from the plan.


      - `no_inn`: Removes all in-network benefits from the plan. You can use
      both `no_oon` and `no_inn` codes together to

      generate a plan without any benefits.


      - `delay_10`, `delay_30`: These codes introduce a delay in the response,
      causing it to wait for either 10 or 30

      seconds before providing an answer.


      - `big_family`: This cheat code adds multiple persons to the result.


      - `not_found`: Using this cheat code will delete all results.


      - `in_err_int`: This cheat code simulates a problem and triggers the
      `unexpected_error`.
  - name: public-auth_Eligibility Result
    x-displayName: Eligibility Result
    description: >-
      Eligibility search result will be sent to all active webhooks once
      available.

      As a fallback, you may call this endpoint to check result status and
      obtain the result.


      ### Status


      The `status` field in the response can have one of the following values:


      `complete` - Indicates that the search has been completed.


      `processing` - Signifies that the search is currently in progress, and it
      is recommended to retry the request later.


      `error` - Suggests that the search dit not finished successfully, and you
      can find descriptions of error codes

      below.


      ### Error codes


      `insurer_problem` – Insurer not available, please try again later


      `unexpected_error` – Unknown error


      ### Webhooks


      Add webhooks to receive results in the [provider
      app](https://provider.anagram.care/webhooks).

      Webhook payload will be identical to the response of this endpoint.


      When configuring a webhook you can provide a secret to sign the webhook
      payload

      and check the signature on the server side.


      Signature will be sent in `X-Signature` header in request to webhook
      endpoint.


      Signature is a request raw data signed with secret by HMAC SHA256
      algorithm. Python example:


      ```

      import hashlib

      import hmac


      def get_signature(secret_key: str, payload: str) -> str:
          return hmac.new(secret_key.encode(), payload.encode(), hashlib.sha256).hexdigest()
      ```
  - name: public-auth_Eligibility Details Request
    x-displayName: Eligibility Details Request
    description: |-
      Requesting plan for patient's eligibility uses the following parameters:

      - Initial request uid (required)
      - Result id from initial request (required)
      - Person id from initial request (required)
      - Details request UID (optional)
  - name: public-auth_Patient
    x-displayName: Patient
  - name: public-auth_Patient eligibility link
    x-displayName: Patient eligibility link
paths:
  /api/auth/v1/patients/{patient_code}/eligibility/:
    parameters:
      - name: patient_code
        in: path
        required: true
        allowEmptyValue: false
        schema:
          type: string
    get:
      tags:
        - public-auth_Patient eligibility link
      summary: List of patient eligibility links
      parameters:
        - in: query
          name: _page_number
          required: false
          schema:
            type: integer
            default: 0
        - in: query
          name: page_size
          required: false
          schema:
            type: integer
            default: 10
      responses:
        '200':
          description: JSON object response
          content:
            application/json:
              schema:
                required:
                  - result
                type: object
                properties:
                  result:
                    type: array
                    items:
                      type: object
                      required:
                        - request_uid
                        - provider_app_url
                      properties:
                        request_uid:
                          type: string
                          nullable: true
                          description: UID provided on request
                        provider_app_url:
                          type: string
                          description: >-
                            An URL that allows getting access to the eligibility
                            results in Anagram Provider App
                        results:
                          type: array
                          items:
                            type: object
                            required:
                              - persons
                            properties:
                              insurer_code:
                                type: string
                                description: 'Example: insurer:vision:vsp'
                              id:
                                type: integer
                              plan_is_active:
                                type: boolean
                                description: Is insurer plan active at the moment
                              status:
                                type: string
                              plan_name:
                                type: string
                              plan_group:
                                type: string
                              plan_group_id:
                                type: string
                                nullable: true
                              plan_begin_date:
                                type: string
                                format: date
                              plan_end_date:
                                type: string
                                format: date
                              plan_refresh_date:
                                type: string
                                format: date
                              persons:
                                type: array
                                items:
                                  type: object
                                  required:
                                    - plan
                                  properties:
                                    first_name:
                                      type: string
                                    last_name:
                                      type: string
                                    dob:
                                      type: string
                                      format: date
                                    sex:
                                      type: string
                                    member_id:
                                      type: string
                                    ssn_last_four:
                                      type: string
                                    type:
                                      type: string
                                    address:
                                      type: object
                                      properties:
                                        line1:
                                          type: string
                                        line2:
                                          type: string
                                        city:
                                          type: string
                                        zipcode:
                                          type: string
                                        state:
                                          type: string
                                    email:
                                      type: string
                                    phone:
                                      type: string
                                    id:
                                      type: integer
                                    full_name:
                                      type: string
                                      description: >-
                                        Can be used instead of first and last
                                        names
                                    is_active:
                                      type: boolean
                                      description: >-
                                        False is person is inactive, True or
                                        None (for compatibility) if person has
                                        active plan
                                    plan:
                                      type: object
                                      required:
                                        - insurer_state
                                        - items
                                      properties:
                                        refresh_date:
                                          type: string
                                          format: date
                                          nullable: true
                                        insurer_state:
                                          type: string
                                          description: >-
                                            Plan includes only in-network (inn)
                                            benefits or also out-of-network (oon)
                                            ones
                                        begin_date:
                                          type: string
                                          format: date
                                          nullable: true
                                        end_date:
                                          type: string
                                          format: date
                                          nullable: true
                                        items:
                                          type: array
                                          items:
                                            type: object
                                            required:
                                              - network_type
                                              - is_authorization_required
                                              - limits
                                              - subitem_limits
                                            properties:
                                              code:
                                                type: string
                                                description: Unique benefit code
                                              copay:
                                                type: number
                                                format: double
                                              network_type:
                                                type: string
                                              is_authorization_required:
                                                type: boolean
                                              refresh_date:
                                                type: string
                                                format: date
                                                description: >-
                                                  Refresh date of benefit if it's
                                                  different from plan refresh date
                                              limits:
                                                type: object
                                                properties:
                                                  quantity:
                                                    type: integer
                                                  total_coverage:
                                                    type: number
                                                    format: double
                                                    description: Total coverage of benefit for period
                                                  quantity_remain:
                                                    type: integer
                                                  quantity_reserved:
                                                    type: integer
                                                  total_coverage_remain:
                                                    type: number
                                                    format: double
                                              subitem_limits:
                                                type: array
                                                items:
                                                  type: object
                                                  required:
                                                    - code
                                                  properties:
                                                    code:
                                                      type: string
                                                      description: code of sub benefit inside benefit
                                                    quantity:
                                                      type: integer
                                                      description: Maximum amount of services
                                                    total_coverage:
                                                      type: number
                                                      format: double
                                                      description: Total coverage of benefit for period
                  prev:
                    type: string
                  previous:
                    type: string
                  next:
                    type: string
              examples:
                Example:
                  value:
                    result:
                      - request_uid: null
                        provider_app_url: https://anagram.care/patients/24
                        results:
                          - insurer_code: insurer:vision:test
                            id: 0
                            plan_is_active: true
                            status: active
                            plan_name: PLAN
                            plan_group: PLAN GROUP
                            plan_group_id: null
                            plan_begin_date: '2024-01-01'
                            plan_end_date: '2025-12-31'
                            plan_refresh_date: '2025-01-01'
                            persons:
                              - first_name: John
                                last_name: Doe
                                dob: '1988-04-01'
                                sex: male
                                member_id: R000000
                                ssn_last_four: '9999'
                                type: self
                                address:
                                  line1: 1234 Main St
                                  line2: Apt 1
                                  city: Los Angeles
                                  zipcode: '90210'
                                  state: CA
                                email: example@anagram.care
                                phone: '1999999999'
                                id: 0
                                full_name: John Doe
                                is_active: true
                                plan:
                                  refresh_date: null
                                  insurer_state: inn
                                  begin_date: null
                                  end_date: null
                                  items: []
                  summary: Retrieve list of eligibilities for patient
        '404':
          description: Patient not found or inaccessible
          content:
            application/json:
              schema:
                type: object
                required:
                  - detail
                properties:
                  detail:
                    type: string
              examples:
                Unknown patient:
                  value:
                    detail: patient not found
                  summary: Patient not found
components:
  securitySchemes:
    ApiToken:
      type: apiKey
      in: header
      name: Authorization
      description: >
        Your API token prefaced with an "Api" prefix. Example value: "Api
        B3F4242424E3FDB4242424242A9C7642"

````