Changelog

#2025-04-29

We've improved our FHIR data quality by implementing the standard data-absent-reason extension for handling missing required properties. Previously, these were represented with text values like "Undefined by source".

Now, missing required properties use the FHIR extension with valueCode: "unknown".

data-absent-reason extension example

{
  "resourceType": "ExplanationOfBenefit",
  "insurer": {
    "extension": [
      {
        "url": "http://hl7.org/fhir/StructureDefinition/data-absent-reason",
        "valueCode": "unknown"
      }
    ]
  }
}

This change ensures our FHIR resources follow the standard more closely and improves interoperability with other FHIR systems.

#2025-04-22

We've added a new usage parameter to the link/token response when using the refresh_token grant type. This parameter indicates whether the patient authorization is a ONE_TIME or MULTIPLE usage authorization, allowing developers to easily determine the authorization type in their token refresh flow.

#2025-03-24

We've added a new Provider Directory to the Flexpa API, powered by NPPES data. This directory allows you to search for healthcare providers and organizations using FHIR's standard search capabilities.

The Provider Directory includes:

Practitioner resources for individual healthcare providers
Organization resources for healthcare facilities and groups

You can search by NPI, name, location, and other criteria using an Application Access Token.

#2025-03-21

We've added client credentials flow to the Node SDK, enabling server-to-server authentication for application access tokens. This allows you to make requests to the Flexpa FHIR API without requiring a patient context using the new FlexpaClient.fromClientCredentials() method.

We've also enhanced our FHIR transformation documentation to provide clearer guidance on how Flexpa transforms FHIR data. The documentation now details Tags, Identifiers, References, Fallbacks, and NPIs.

#2025-03-17

We've added detailed schema definitions for the Practitioner and Organization resource types. These schemas provide a comprehensive overview of the structure and data types you can expect when working with provider data through the Flexpa API.

#2025-03-14

We've introduced a powerful new authentication feature to the Flexpa API: Application Access Tokens. These tokens provide application-level authentication for the Flexpa FHIR API, distinct from patient-level access. With Application Access Tokens, you can make requests to the API without requiring a patient context.

Application Access Tokens are implemented using the OAuth 2.0 Client Credentials Grant Flow, which enables secure server-to-server authentication using your application's credentials. These tokens use the JWT format with ES256 signatures and have a short 30-minute lifetime for enhanced security.

You can obtain Application Access Tokens through our Token Endpoint, the same endpoint used for refreshing Patient Access Tokens.

#2025-02-26

The timeUntilMaxAuth response parameter has been added to the link/token endpoint. This parameter indicates the time (in seconds) until the patient authorization reaches its maximum authorization period, after which the patient will need to re-consent to continue accessing their data.

#2025-02-25

We've added a new timeUntilMaxAuth response parameter to the link/introspect and /link/exchange endpoints. This parameter indicates the time (in seconds) until the patient authorization reaches its maximum authorization period, after which the patient will need to re-consent to continue accessing their data. This is particularly useful for applications using MULTIPLE usage patient authorizations to proactively manage re-consent flows.

#2025-02-10

We've enhanced the Flexpa consent flow to include plan type selection (Medicaid, Medicare Advantage, Individual, or Employer). This additional data point enables our team to provide more targeted and efficient troubleshooting support when needed.

Additionally, we've streamlined the support request process with improved logging capabilities and a more concise form. These updates ensure that when users encounter issues, they can quickly and effectively alert our support team.

#2025-02-06

We are now requiring the Bearer word in the Authorization header of FHIR requests. Authorization headers must be formatted as Authorization: Bearer <token>.

Previously, we supported requests without the Bearer word.

Requests will continue to work until May 1, 2025. We will proactively notify and resolve any usage of this deprecated behavior before final removal.

#2025-02-04

The Patient $everything operation now returns Organization, Location, Practitioner, and Medication resources if they are present in the patient's FHIR data. Previously, the $everything operation was limited to only patient-compartmentalized resources.

#2025-01-13

X-Flexpa-Raw: 0 | 1 is now fully deprecated. Flexpa API will now ignore this header. All FHIR requests directly read from our cache.

#2024-11-05

Flexpa API now supports backfill missing display names for provider codes in the FHIR data that Flexpa receives from payers. This feature is available for provider codes in the NPI code system.

Payer data can sometimes omit display names for provider codes, which can make it difficult to understand which providers your patients have had claims for. This feature solves that problem by providing display names for providers directly in the name field of the Practitioner and Organization resources.

Backfilling Practitioner names

{
  "resourceType": "Practitioner",
  "id": "123",
  "identifier": [
    {
      "system": "http://hl7.org/fhir/sid/us-npi",
      "value": "1234567890"
    }
  ]
}

Backfilling Organization names

{
  "resourceType": "Organization",
  "id": "123",
  "identifier": [
    {
      "system": "http://hl7.org/fhir/sid/us-npi",
      "value": "1234567890"
    }
  ]
}

#2024-10-30

We've launched a feature to backfill missing display names for medication codes in the explanation of benefit FHIR data that Flexpa receives from payers. This feature is available for medication codes in the NDC code system.

Payer data can sometimes omit display names for medication codes, which can make it difficult to understand what medication your patients have had claims for. This feature solves that problem by providing display names for medication codes directly in the coding array.

Backfilling medication names

{
  "resourceType": "ExplanationOfBenefit",
  "id": "123",
  "item": [
    {
      "productOrService": {
        "coding": [
          {
            "system": "http://hl7.org/fhir/sid/ndc",
            "code": "0777310502"
          }
        ]
      }
    }
  ]
}

#2024-10-08

We've expanded our adjudication code normalization logic to now include codes in the itemized field of an ExplanationOfBenefit. For supported endpoints, the item[x].adjudication array will now contain a consistent set of codes. Previously only the total array was normalized.

This change allows developers to reliably understand the adjudication breakdown of ExplanationOfBenefit resources at the item level.

#2024-09-16

We've renamed the Access Tokens Logs page in Flexpa Portal to Authorization Logs. This change is to better reflect the data displayed in the logs and aligns with the data available in the introspect route. We've also removed the current and refreshed from fields as they are not associated with a specific patient authorization.

#2024-09-13

We've updated /link/introspect to return the counts of currently accessible resources for the patient in the sync.resourceTypes property.

#2024-09-10

We are adjusting one of the small transformations we make to data ingested by our system. Specifically, we are replacing one of the systems we use to tag resources. Previously we would tag the resources with a system of "https://fhir.flexpa.com/identifiers/PatientAccessTokenMode". This was meant to represent the mode of authorization used. However, it was a misnomer. Now it is correctly named "https://fhir.flexpa.com/identifiers/PatientAuthorizationMode".

This data will not be changed retroactively.

#2024-08-05

We've added a new guide to help you understand how to work with financial data in FHIR.

This guide covers the theory of financial liability and payments in FHIR and describes how Flexpa normalizes financial data from payers to make it easy to work with.

#2024-07-31

The Exchange API now includes a user property in the response body.

This change makes it easier to associate a patient access token with a user in your system.

#2024-06-17

We've published a new usage guide to help clarify each flow and help you make a decision based on your data usage needs.

#2024-06-13

Flexpa now maps old adjudication codes from v0.1.0 of the CARIN BB FHIR IG to the latest adjudication codes from v2.0.0.

This change ensures that developers can work more reliably with adjudication codes. Specifically, developers no longer need to worry about which version of the CARIN BB FHIR IG an ExplanationOfBenefit resource conforms to.

For more information on how Flexpa maps these codes, see the Adjudication section of the Financial guide.

#2024-06-07

The Introspect API now includes an active response field. The active field is a boolean that states whether the access token can be used.

#2024-05-30

The usage parameter is now a required field in the create() method of Flexpa Link. This parameter determines the duration of the patient authorization and can be set to either ONE_TIME for 24-hour access or MULTIPLE for ongoing access. For more details, please refer to the Flexpa Link documentation.

#2024-05-20

In Flexpa Link, when MULTIPLE is used as the usage param and the user-selected endpoint has refreshable set to false, we now automatically fallback the usage value to ONE_TIME for any relevant patient authorizations.

This means that you will not incur charges related to auto-updating for endpoints that cannot be refreshed.

You can view the usage value in the response of the Exchange and Introspect APIs.

#2024-05-17

We have updated our Test Mode policy. Starting today, using Test Mode requires the signing of a Service Agreement.

Please note there is now a monthly platform fee to ensure best-in-class integration support by our engineering team.

#2024-04-26

The /link/refresh API will be officially deprecated on June 1st, 2024. After this date you will no longer be able to use the /link/refresh API. We urge you to begin transitioning as soon as possible to avoid any service interruptions.

Our Multiple Use feature is designed to simplify the management of long-term patient authorizations by maintaining them automatically, ensuring continuous access without the need for manual refreshes.

If you're using the /link/refresh API and have questions or need guidance on switching to the Multiple Use feature, contact us at support@flexpa.com.

#2024-04-02

We've updated Flexpa Link with enhancements to manage long-term patient authorizations better. The new usage field within the create() method allows for clear designation between single (ONE_TIME) and ongoing (MULTIPLE) data access needs.

MULTIPLE usage simplifies how you maintain access to patient data over time. Flexpa automatically keeps patient authorizations active and current, eliminating manual refreshing and resyncing. This change streamlines the refresh process, eliminating the need to track the variability of refresh expiration periods across different payers. When using the Exchange API, you'll receive a refresh_token that remains valid for a consistent 90-day period. To generate new access tokens, you can use this refresh_token with the new Token Refresh API.

With the shift towards a more streamlined approach, we have deprecated our previous refresh API. Check out the updated Flexpa Link documentation to understand how to incorporate these changes into your workflow.

#2024-03-14

We've published the Flexpa Node SDK NPM package to make it easier for developers to interact with the Flexpa API. You can install the package by running yarn install @flexpa/node-sdk in your project. See the docs and the Node SDK package for more information on how to use the package.

#2024-03-05

We've updated the sync object to include both the lastSyncedAt and state fields in the response of the introspect endpoint. lastSyncedAt indicates when the patient's data was last succesfully synced to our cache, and state shows the sync job's current status. This provides a clearer insight into the freshness of the data.

We also added the same sync object to the response of the exchange, and refresh endpoints for a more consistent experience when working with Flexpa API.

#2024-03-04

Now, the sub claim in access tokens obtained through the exchange and refresh routes consistently uses a unique identifier for each patient authorization initiated via Flexpa Link. This identifier ensures continuity and consistency across token refreshes, maintaining a direct association with the specific patient authorization context. We've also added the claims aud, iss, and client_id to the JWT access token.

#2024-02-28

Our Developer Portal now uses e-mail based verification during the authentication process instead of a password. You will now be redirected to https://authentication.flexpa.com to complete the authentication process.

#2024-02-22

We are now requiring the create() method of Flexpa Link to be called with a user object.

This change is to ensure that individuals who authorize via Flexpa are mapped correctly from your application to Flexpa. This mapping is important for Flexpa to provide the best support to patients and developers.

#2024-02-09

Our new API architecture is now out of beta and is the default behavior for all customers. This change ensures a consistent experience for developers with longer access uniformly across all endpoints.

If you would like to discuss the enhanced feature set of the new API or encounter issues, please contact us at support@flexpa.com

#2024-02-07

We've added a new sync property to the response body of the Introspect API that includes information about the sync job of the patient authorization. Nested in sync is a resourceTypes property that summarizes the resource types that were successfully synced after the patient authorized with Flexpa. sync.resourceTypes is an object that includes counts per resource type.

With this information, developers can accurately expect the types of data which is available for a patient to make better-informed decisions about how to retrieve it.

Previously, the response from the Introspect and Exchange APIs included a resources property that listed the resources that were supported by the payer's FHIR server. However this information was not always accurate, and it was not always clear which resources were actually available for a patient. For this reason, we have removed the resources property from the response of the Introspect and Exchange APIs.

#2024-02-05

Flexpa Link is available in English, Spanish, and now Korean. Users can easily toggle between languages by using the buttons in the bottom right corner of the UI.

#2024-02-02

We've added a new optional parameter to Flexpa Link's create method: skipExplainer.

Setting skipExplainer to true will skip Flexpa Link's explainer step following the consent screen and instead redirect the patient to their payer authorization immediately after the patient clicks 'Continue' on the consent screen.

#2024-01-25

The response from the Introspect API now includes a user object containing the externalId if one was provided when the authorization was created with Flepxa Link.

#2024-01-23

We've configured a standard data retention policy in our FHIR server. Data is automatically deleted from our FHIR server as soon as the access token associated with the data expires. This means that data older than 24 hours is deleted.

Previously, we did not have a standard data retention policy, and data was stored indefinitely. This change ensures that we are only storing data for the minimum amount of time necessary to provide our services.

#2024-01-17

We've standardized access token expiration times to 24 hours for all payers. This means that all access tokens will expire 24 hours after they are issued by the Exchange API. The responses from the Exchange API and Refresh API will now necessarily include an expires_in field with a value of 86400 seconds.

Previously, access token expiration times varied by payer, ranging from minutes to hours. This change will ensure a consistent experience for developers with longer access uniformly across all endpoints.

This change comes as one of the many improvements for developers in our improved API experience.

#2024-01-10

We've added a new optional parameter to Flexpa Link's create method: requestedResources.

Providing a requestedResources array allows you to define specific resource types that are synced for the patient, which can reduce the amount of time you and your patients will wait for the sync to complete.

#2023-12-05

Flexpa API now supports the Patient $expunge route. This route allows you to delete all data scoped in a specific Patient resource compartment while preserving the ability to refresh the patient access token.

#2023-11-27

We've updated the https://api.flexpa.com/fhir/metadata route to return Flexpa's CapabilityStatement. We've also removed the requirement for an Authorization header when making requests to this route.

Previously, this route returned a CapabilityStatement that was generated by the Endpoint FHIR server that a patient was authorized to. This was not a Flexpa-specific CapabilityStatement and did not include Flexpa-specific information.

Flexpa's CapabilityStatement is the only CapabilityStatement needed to use Flexpa's new API successfully.

#2023-11-22

Flexpa Link will show all payers available in the US, including the appropriate status to indicate whether Flexpa is still implementing. For payers we are still implementing, it will show "Not yet available" and allow the user to request the endpoint. This feature allows users to know concretely that they've searched for their payer correctly and allow them to contact Flexpa about that payer.

Previously, Flexpa Link only showed payers that Flexpa had completed implementation with and established connectivity.

#2023-10-27

We've added a new argument to the create method of Flexpa Link: user. This argument allows you to pass in a user object that will be associated with the patient access token generated by Flexpa Link.

Providing a user object yields the following outcomes:

The user can be associated with multiple Patient Access Tokens, allowing for improved insights into user behavior.
Flexpa enforces logical isolation of the user's data between family members if the payer does not implement appropriate Access Control Limits.

#2023-10-17

We've updated the Flexpa API architecture to ensure we consistently deliver the operations and search parameters needed by customers and ensure a reliable, expectable, and performant API experience when making FHIR requests.

You can read more about the new Flexpa API architecture here.

The feature is in beta and can be utilized by adding the HTTP header X-Flexpa-Raw: 0 to FHIR requests. This will be the API behavior once released to general availability. After the initial stabilization period, all customers will be migrated to this new architecture.

#2023-10-10

We've added patient access token logs to Flexpa Portal for more streamlined troubleshooting and improved understanding of user behaviors. You can now see a history of all patient links through your application with information about their state, error messages, and endpoints.

#2023-10-04

We have added details around how customers can validate their live mode connection using our "Flexpa Live Mode Sample Patient" endpoint.

This allows customers to validate their live mode credentials and configuration without having to have a patient authorize with a payer.

#2023-10-03

We've fixed a bug related to CORS issues and updated our Quickstart to route FHIR requests through the local backend server. If you are testing with our Quickstart, we recommend synchronizing this latest version to understand how to route requests through the backend server.

#2023-09-18

We've enhanced the workspace dashboard in Flexpa Portal, adding step-by-step user guidance for test and live mode setup. This guided experience is designed to offer greater clarity on getting started with Flexpa.

Additionally, the application and team management sections have been moved to separate pages in the sidebar navigation.

#2023-09-05

You can provide autoExit: false to Flexpa Link's create method to prevent the modal/dialog from closing automatically upon completion. Defaults to true if not provided.

#2023-08-29

We added new documentation about installing Flexpa Link in mobile applications to better assist implementers.

#2023-08-09

We deprecated the /payers route and the payer response property of the endpoints API.

Instead, developers should reference the /organizations route and the organization response property of the endpoints API.

This is the final step of a renaming initiative that was described on 2023-07-19.

#2023-07-19

We renamed the "payers" API to "organizations" and renamed the payer response property of the endpoints API to organization.

Both old and new naming conventions will be supported until August 9, 2023, after which only the new naming convention will be used.

We did this because an "organization" can be either a payer, provider, or a vendor entity.

#2023-07-18

GET /link/introspect in Flexpa API now has a state field in its response. This can be used to determine if a Patient Access Token is not only valid but potentially usable or refreshable.

#2023-07-11

We removed the string " application" from all application names in our database. This string was previously appended due to legacy code which we have since deprecated.

With this update, Flexpa Link's header now is cleaner and easier for users to read when they link their health plans.

#2023-07-10

Previously, there was no easy way to handle errors that occurred during the Flexpa Link authorization flow. This could leave developers in the dark about issues that users were encountering, and it could leave users frustrated with a broken experience.

With this update, the onExit callback now has an optional error parameter, provided when members proceed through the authorization flow but encounter an error. This enables developers to handle these errors gracefully, by perhaps showing the user an error message or logging the error for later debugging.

#2023-06-28

We are making a change to improve the user experience within Flexpa Link. From now on, endpoints undergoing downtime will be automatically deactivated and will no longer be available for user selection.

Flexpa is committed to providing a seamless user experience. As part of our quality assurance process, we routinely monitor our connected endpoints to ensure they are functional. In instances where we detect downtime, we have previously shown their status in Flexpa Link but still allowed users to proceed.

However, we recognized that this could potentially result in a suboptimal user experience as unsuccessful connections may occur. To prevent such issues, we have updated our system to automatically deactivate any endpoints detected to be experiencing downtime.

This change will ensure a smoother and more reliable connection experience for our users. We appreciate your understanding and cooperation.

#2023-06-20

Flexpa Link is now available in both English and Spanish. Users can smoothly toggle between languages using designated buttons in the UI, ensuring a more inclusive user experience.

#2023-06-16

Understanding the health of the endpoints you and your users care about is important. While we previously surfaced this information in Flexpa Link, we've now added this information to our general documentation.

In order to provide the best visibility into the status of endpoints you may need to connect to, we've added the status detail to our endpoint directory. This detail will provide a high-level overview of the status of an endpoint, including whether it is currently available.

This is also programmatically available via the Flexpa API.

#2023-06-15

Link exchange and refresh responses may now include a refresh_expires_in value. This represents the time in seconds for which the access_token is refreshable, after which the user will be required to re-authorize your application to the payer.

The availability of refresh_expires_in is subject to the Endpoint's support of the feature.

#2023-06-07

In this update, we've made some significant enhancements to the loading screen and user flow to ensure a more seamless and transparent experience.

To make the loading process more intuitive and user-friendly, we've enriched the loading screen with troubleshooting tips and guidance for handling common authorization challenges.
To improve patients' understanding of the process, we've introduced a new step in the flow. This step provides a clear explanation of what happens when you are redirected to a payer's member portal or identity provider to validate your credentials.
To increase context on errors, we've improved the error screen when a patient's plan is ineligible, allowing the patient to request support for their plan.

#2023-05-25

The revoke endpoint of the Flexpa API now invalidates all authorizations that a patient had previously made to an application. Read more about these details on the revoke section of the Flexpa API documentation.

#2023-05-12

Flexpa's API now works behind the scenes to standardize code system URIs in FHIR responses.

We've added a page that references which code system URIs developers can expect to see in FHIR payloads.

#2023-04-21

While MyFlexpa has existed for a long time, our documentation on its value and use for patients and developers have not.

We've added a page that details how to best use this tool alongside other Flexpa offerings.

#2023-04-12

We've added a new way to use our docs: FlexpaGPT. Ask questions about Flexpa and get back responses instantly.

A button displayed on the bottom right of the page that will open up a chat window
Ask questions about Flexpa and get answers instantly
FlexpaGPT links to relevant documentation, code snippets, and more

#2023-03-13

We've added an indicator to the Flexpa Link endpoint selection screen to notify patients when an endpoint connection is unstable.

The indicator will display as a message in red above the affected endpoint's label
This enhancement improves the patient experience by increasing their awareness of known endpoint issues and encouraging them to retry later

#2023-03-03

Flexpa Link now displays health plan logos in the selection screen. This update should improve plan recognition and help patients identify their health plan correctly.

#2023-02-07

We've updated the styling of the health plan selection screen in Flexpa Link for better usability. This new design removes the coloured backgrounds to improve the contrast ratio and provide a more consistent experience.

We also have updated our health plan search to more robustly identify the plans a patient may be searching for. This includes fuzzy matching on searches and searching across applicable brand names a payer may use.

#2023-02-03

The exchange endpoint of the Flexpa API now returns additional metadata about the health plan (Endpoint) a patient has used to authorize your application.

This metadata includes attributes such as the Endpoint name, whether or not the authorization is refreshable, and a list of FHIR Resources available for this Endpoint.

Read more about these details on the exchange section of the Flexpa API documentation.

#2023-01-17

Flexpa Link (0.0.10) now supports onExit and onLoad callback functions passed to create.

onExit is called when the user exits the authorization flow without succesfully authorizing
onLoad is called when Link is loaded and ready to be used

#2023-01-05

We have released Flexpa Connections, an application that lets patients manage their health plan authorizations.

Patients can log in with their health plan and view a history of applications they've connected through Flexpa Link
Patients can disconnect apps they no longer want their health plans connected to and reconnect them anytime through Flexpa Link
Check out the Flexpa Connections documentation for more information

#2023-01-04

After user testing and customer feedback, we have removed all minimums from our Basic plan. This pure usage-based pricing should allow early testing and onboarding, aligning value with predictable cost. Check out additional details here.

#2022-12-15

The introspect endpoint of the Flexpa API now returns additional metadata about the specific endpoint associated with the access token you are using. Read more about these details on the introspect section of the Flexpa API documentation.

#2022-11-09

Flexpa Link (0.0.8) now supports the option to skip the health plan search / select step in our authorization flow.

This supports an improved UX flow in cases where a patient's health plan is known to the application implementing Flexpa Link prior to starting the authorization.

Provide an optional parameter called endpoint to the Flexpa Link create or open functions to skip health plan search / select
Reference documentation for available Endpoints

#2022-10-31

Patient access tokens created with Flexpa Link now have support for a refresh mechanism. Refreshing a patient access token allows your application to make requests after the original one has expired.

Where possible, Flexpa obtains an offline_access scope and exposes a refresh route
Refreshing a patient access token will invalidate the previous patient access token and return a new one

Note that not all patient access tokens support refreshing. Major payer support includes Kaiser Permanente, Cigna, Humana, UnitedHealth, and Anthem.

#2022-10-18

We are launching a small guide on basic data analysis with FHIR bundles you get from Flexpa API.

This guide explains how to go from raw FHIR bundles from Flexpa API, and transform them into structured tables that conform to Tuva's data model
We've co-developed a FHIR parser with Tuva that converts FHIR bundles into database-ready CSVs for structured analysis

#2022-10-17

We are launching pagination support to simplify accessing FHIR Resource search results.

Developers can pass the query parameter _count into search requests and use the returned link object to access the paginated results
More information about pagination is available on the API reference page

#2022-10-07

We are launching the Flexpa Portal, a new way for developers to manage their Flexpa account.

This new option allows for developers to create an account, generate API keys, and invite other members of their organization to collaborate.
Our portal can be accessed here

#2022-08-30

We are launching the ability to customize the appearance of Flexpa Link with the customLinkConfig configuration object.

This new configuration object provides a way to configure Flexpa Link to match implementers' UI/UX more closely
Initially supporting four brandColors: red, green, blue, and yellow
Instructions on implementation available here

#2022-08-03

We are launching the new patient access guide and FHIR Resource reference pages.

The newly updated patient access guide provides a background on Patient Access APIs and the data they make available
The FHIR Resource pages provide sample request and response data for FHIR Resources (ex. Coverage) that can be accessed using Flexpa API

#2022-06-29

We are launching the Wildcard Parameters feature in Flexpa API. This allows you to reference real values provided by the Patient Access Token in each request.

The first parameter we are supporting is $PATIENT_ID, allowing you to use the currently authorized patient_id in each request without having to know what it is.

Removes the patient_id as a field in the response of POST /link/exchange
Updates FHIR Server to accept Wildcard Parameter, $PATIENT_ID

Example requests:

GET /fhir/Patient/$PATIENT_ID -H "Authorization: $ACCESS_TOKEN"
GET /fhir/Coverage?patient=$PATIENT_ID&_count=5 -H "Authorization: $ACCESS_TOKEN"
GET /fhir/ExplanationOfBenefit?patient=$PATIENT_ID -H "Authorization: $ACCESS_TOKEN"

Note: Using the introspect endpoint and sending the actual patient_id will also continue to work.

#2022-06-22

We are launching the NodeJS-based Quickstart repository and accompanying guide.

The Quickstart Github repository is a cloneable project to help you get started with Flexpa in just a few steps
The Quickstart guide walks through how to build and run Flexpa's quickstart example

#2022-06-15

We are launching Flexpa Link and Flexpa API, including our major feature release of self-service test mode API keys.

Flexpa Link is a client-side component to help your users link health plan data sources
Flexpa API is a unified HL7 FHIR API (HTTP + JSON) to access health plan, claims, and clinical data

Getting started:

Get API keys at flexpa.com/docs
We recommend starting with the Quickstart
From there, you can make requests to the Flexpa API (like with our EOB claims history guide)