Skip to main content


         This documentation site is for previous versions. Visit our new documentation site for current releases.      
 

Pega Foundation for Healthcare 8.7 common objects API technical specification guide

Updated on April 23, 2021

About Pega Healthcare API services

The Pega Healthcare API enables you to leverage built-in REST/JSON services to integrate your Pega applications with external systems to request, receive, and send data. You can call any of the Pega Healthcare API services by using standard HTTP methods (for example: GET, POST, or PUT). The supported APIs provides a standard set of services and requests that include access to data pages for commonly referenced objects in healthcare applications e.g., Member, Provider, Claim and so on. These APIs enable rapid deployment of your Pega’s healthcare applications.

Accessing Pega Healthcare APIs

Pega offers online help documentation on the healthcare APIs. You can access the Pega Healthcare API help documentation from the Dev Studio menu.

The API information is organized as Business Request API methods to GET (request) data from third party applications based on parameters passed in the request.

Using the above links, you can:

  • View the JSON data model for each published resource
  • List the parameters used for each resource
  • Directly test the API by clicking the Tryit out! and viewing the actual request URL, response body, response code, and response headers.

Swagger rendering in Pega does not support embedded definitions – When a given definition is reused more than once in the API e.g., ‘Address’, it is displayed as Null. To overcome this issue, these attributes are repeated with a slightly different name e.g., Address and AddressEntity as shown in the Payer model above.

Published Healthcare APIs

Business service APIs

  • Authorizations

    • Get Authorization by ID

    • Get Authorizations by Member Policy ID

  • Benefits

    • Get Benefit Coverage (in the context of member’s claim line)

  • Business Entities (Provider)

    • Get Provider Business Entity

  • Business Affiliations (Provider)

    • Get Provider Business Affiliation

  • Provider Contracts

    • Get Provider Contract

  • Claims

    • Get Claims History (for member)

  • Employer Group Contracts

    • Get Employer Group Contract

  • Members

    • Get Member

    • Get Member Policies

    • Get Member Networks

  • Networks

    • Get Network

  • Payers

    • Get Payer

  • Plan Networks

    • Get Plan Network

  • Policies

    • Get Policy

  • Providers

    • Get Provider

    • Get Provider Networks

  • Rate Sheets

    • Get Rate Sheets

API integration classes

The Healthcare API infrastructure provides an integration class for each published API resource. This class defines the data model used in mapping the response data returned via API call. The classes are configured as PegaHC-Int-xxxxx as shown below.

Note: The sample rules shown in the next two chapters are shown using the Payer resource as an example. Each published resource API has similar rules associated with it.

Business request APIs

Connector rule for API

The Healthcare API infrastructure contains pre-configured specified endpoint URL and populates the returned result in data pages. The following diagram illustrates the flow of execution:

Key rules in business request API execution

Rule NameRule TypeUsage

D_Connect<Resource>

e.g., D_ConnectPayer

Data PageCalls the connector and identifies the request and response mapping rules
Get<Resource>Connect RESTCalls the REST Service using endpoint URL
MapRequestDataData TransformMaps the request data
MapResponseDataData TransformMaps the results data to data page
MapToEntityData TransformMaps the results to the Payer object

Connector data page

The Connector data page for each Resource provides the configuration for the data page definition and the data source(s) that are used to fetch the data. It also identifies the request and response data mapping rules. The following Connect Data pages are configured for the APIs.

As shown below, the Source for the data is configured as a Connector which invokes the external system REST service using the endpoint URL. The Endpoint URLs for all configured services in Healthcare API are fetched through a dynamic settings data page called D_HCSettings as explained later in this document.

Connect REST rule

The Connect REST rule supports the interaction between Pega and other systems over the Hypertext Transfer Protocol (HTTPS). It identifies the resource path endpoint URL of the source system to which this rule connects, and the parameters used to pass in the request. Refer to Pega online Help for additional information on configuring Authentication, Security Settings, and Error Handling.

Above connector rule is configured with a OOTB Basic Authentication profile ‘CommonObjectAuthProfile’ to configure the appropriate user credentials to be able to invoke the services that are configured to test the corresponding Business Request APIs with the sample data provided in Pega Foundation for Healthcare.

Dynamic settings end point URL management data page

You cannot modify the End Point URL resource path configured on a Connect REST rule once you finalize and lock the rule. To be able to maintain different end point system URLs and reference them dynamically, the Healthcare API configuration provide a pre-configured node level dynamic settings data page called D_HCSettings. As shown above, this page is referenced as a parameter to retrieve the Endpoint URL for the given resource.

The data source configured to fetch the end point URL is a Data Transform rule called LoadHCSettings. The rule is configured with URLs for a test reference system used internally for testing the Healthcare APIs. The rule is marked for Extension and is expected to be updated in your application with URLs for your own source systems for the different resources.

Map request data

The MapRequestData data transform rule provides the parameter(s) passed in the request API.

Map response data

The MapResponseData data transform maps the response received from the source system. The data received as JSON format is stored in Param.Response which is then mapped to appropriate object class in your application. In this example, the returned payer information is mapped to payer class using the MapToEntityWrapper data transform rule.

Wrapper map rule

A wrapper rule envelops each mapping rule for every resource API published in the Healthcare APIs. The wrapper rule contains the Pre and Post extension points to extend the mapping in your implementation. These rules are marked for Extension and you should extend as per your need. The expectation is that you maintain the main mapping rule included in the wrapper rule as is to allow Pega to maintain backward compatibility with the Pega-provided mapping rules. See the “Extending your APIs” section defined later.

Resource map rule

The configured mapping of the expected response for each Resource is configured in this data transform rule.

Business service API

Healthcare API - service package rule

The key service package rule is called Healthcare API. It lists all the REST services published in this release.

Note: Basic authentication is enabled for above service package to prevent any unauthorized access and hence appropriate authentication profile needs to be created and used while invoking any services that belong to above service package.

Note: The key Business Service API is for the Claim resource. The list of service rules shown above also includes additional service rules for other resources that are configured to test the corresponding Business Request APIs with the sample data provided in Pega Foundation for Healthcare.

REST service method

The Healthcare API provides a mechanism for an external system to call the Pega Healthcare API REST services. The schematic shown below illustrates the flow of the REST service execution using ‘Payer’ as an example.

Key rules in service execution

Rule NameRule TypeUsage
<Resource>Service RESTREST service rule that identifies the path, parameters, and methods
Get<Resource>APIActivityMethod in REST service to get Payer details
MapFrom<Resource>Data TransformMap results from PFHC Payer to API Integration object

Service REST rule

Each Resource published in the Healthcare API has a pre-configured REST Service rule that identifies the key properties including the path and parameters as well as all the methods configured for the Resource. Let’s look at an example below for the Payers API.

Resource and query parameters

The Resource and Query parameters configured on the REST Service rule are used to form and call the appropriate endpoint system URL. In the following example, the payer ID is passed as resource parameter, which will convert endpoint URL.

http://vfwiapppgr063:8080/prweb/PRRestService/healthcareapi/v1/payers/%7BID%7D

The Methods tab of the rule defines any of the methods - GET, PUT, POST defined for the Resource along with the parameters for each method.

Service activity rule

Each method defined on the Resource REST Service rule has an activity rule that kicks-off the process when the Service Method is executed. The requested data is retrieved using the endpoint URL of the source system using the parameters that were passed in the Method.

The data that is returned from the source system is mapped to the Integration class for the Resource as shown earlier. Results of this request will be stored in Param. Response and passed to data page.

Mapping data transform rule

The Activity defined in the Service Method calls a mapping Data Transform rule to map the returned data to the appropriate data page.

Extending Pega Healthcare APIs

The Healthcare APIs provide a mechanism for your application to extend the wrapper rule of every resource. A wrapper rule envelops each mapping rule for every resource API published in the Healthcare APIs. The wrapper rule is provided as a placeholder for extending the mapping in your implementation.

These rules are marked for Extension and you should extend them as per your need. It is expected that the main mapping rule included in the wrapper rule is maintained as is to allow Pega to maintain backward compatibility with the Pega-provided mapping rules.

MapToEntity extension pattern

This method describes the new API mapping paradigm. In this method, the pattern is described using the Authorization API as an example.

Inbound mapping

The mapping begins at the connect Data page i.e., D_ConnectAuthorization. The Connector data page for each Resource provides the configuration for the data page definition and the data source(s) that are used to fetch the data. It calls the connector and identifies the request and response data mapping rules.

MapRequestData: The MapRequestData data transform rule provides the parameter(s) passed in the request API.

MapResponseData: The MapResponseData data transform maps the response received from the source system. The data received as JSON format is stored in Param. Response which is then mapped to appropriate object class in your application. In this example, the returned authorization information is mapped to Authorization data class using the MapToEntityWrapper data transform rule.

MapToEntityWrapper: MapToEntityWrapper accepts a single Page Name parameter called Integration Page. In this case the parameter will be the ‘Authorization’ page of type ‘PegaHC- Data-Authorization.

The data transform serves as a control point for making calls out to a series of three additional Data Transform rules that provide the core mapping functionality as well as the appropriate extensibility needed by customers:

MapToEntity: a single MapToEntity rule exists in @baseclass and this rule is overridden in each of the classes that need to supply their own definitions. In the new implementation ‘MapToEntity’ would exist in the ‘Int’ classes and have the corresponding mappings. In the current example, we have the ‘MapToEntity’ data transform in the ‘PegaHC-Int-Authorization’ class. It contains the mappings related the authorization object.

The ’MapToEntityWrapper’ paradigm will be extended to all the embedded pages/objects as well. In the example, the authorization JSON response has a ‘requester’ page with page definition ‘PegaHC-Int-AuthorizationRequester’. We intend to map this page to the ‘Requester’ page on the PFHC Authorization object. The ‘Requester’ page is set as the parameter to the ‘MapToEntityWrapper’, which in turn invokes the ‘MapToEntity’ in the ‘PegaHC-Int-AuthorizationRequester’ class.

HTTP status codes

Success codes

HTTP Status CodeDescription
200Success(OK)
201Created
204No content

Error codes

HTTP Status CodeDescription
400Bad request
401Unauthorized
403Forbidden
404Not found
412Precondition failed
500Internal Error

Healthcare API - key

Business request APIs

Authorizations - GET authorization details

This connector rule takes Authorization ID (certification number) as input parameter and returns the authorization details in data page.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/authorizations/{ID}

Parameters

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-Authorization
authorizationsConnect REST
GetAuthorizationsActivityMethod in REST service to get authorization
MapFromAuthorizationData TransformMap results from PFHC Authorization to API Integration object
D_ConnectAuthorizationData PageTo call connector and map request and
GetAuthorizationConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformTo map the results to PFHC Authorization object

Authorizations - GET authorizations by member policy ID

This connector rule takes Authorization ID (certification number) as input parameter and returns the authorization details in data page.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/memberAuthorizations/{MemberPolicyID}

Parameters

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-Authorization
memberAuthorizationsConnect REST
GetMemberAuthorizationsActivityMethod in REST service to get authorization
MapFromAuthorizationData TransformMap results from PFHC Authorization to API Integration object
D_ConnectMemberAuthorizationsData PageTo call connector and map request and
GetMemberAuthorizationsConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapMemberAuthorizationsResponseDataData TransformTo map result data to data page
MapToEntityData TransformTo map the results to PFHC Authorization

Benefit request - POST benefit details

URL format

POST https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/Benefits

Parameters

This connector rule takes PlanBenefitRequest as a parameter which is claim Line details for a claim to fetch the coverage for particular line item.

PlanBenefitRequest {

claimLineNumber (string, optional), planID (string, optional), serviceFromDate (date, optional), serviceToDate (date, optional),

revenueCode (string, optional), procedureCode (A00.1, optional),

placeOfService (string, optional), diagnosis (string, optional),

age (string, optional), gender (string, optional), DateOfBirth (date, optional), billType (string, optional),

networkRelationship (string, optional), AdmissionType (string, optional),

IRC (string, optional), Modifier (string, optional), Providerype (string, optional)

}

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-Benefit
D_ConnectPlanBenefitCoverageData PageTo call connector and map request and
PlanBenefitCoverageConnect RESTCall REST Service using endpoint URL
MapBenefitCoverageFiltersData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToPlanBenefitCoverageWrapperData TransformWrapper DT which calls ‘MapToPlanBenefitCoverage’ and can be
MapToPlanBenefitCoverageData TransformMap results to PFHC Plan Benefit object

Business entities - GET business entity

Business Entity API takes TIN or Tax ID as required field to fetch details and effective, end dates are optional parameters. Foundation provides OOTB connector data page which invokes the external system REST service using endpoint URL. Below are key rules:

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/businessentities/{TIN}

Parameters

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-BusinessEntity
businessEntitiesConnect REST
GetBusinessEntitiesActivityMethod in REST service to get Business Entity
MapFromBusinessEntityData TransformMap results from PFHC Business Entity to API Integration object
D_ConnectBusinessEntitiesData PageTo call connector and map request and
BusinessEntitiesConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Business Entity object

Business affiliations - GET business entity

Business Affiliations API takes ID which is a comma delimited string of Provider ID, BusinessEntity ID and Effective Date (in the same order) as parameters to fetch business affiliation details.

Foundation provides OOTB connector data page which invokes the external system REST service using endpoint URL. Below are key rules:

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/businessaffiliations/{ID}

Parameters

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-BusinessAffiliation
businessaffiliationsConnect REST
GetBusinessAffliationsActivityMethod in REST service to get business
MapFromBusinessAffiliationData TransformMap results from PFHC Business Affiliation to API Integration object
D_ConnectBusinessAffiliationData PageTo call connector and map request and
GetBusinessAffiliationConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Business Affiliation object

Policy - GET policy details

Policy API takes ID which is Policy ID as the parameter to fetch policy details.

Foundation provides OOTB connector data page which invokes the external system REST service using endpoint URL. Below are key rules:

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/policies/{ID}

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Policy

policiesConnect REST
GetPolicyAPIActivityMethod in REST service to get policy details
MapFromPolicyObjectData TransformMap results from PFHC Policy to API Integration
D_ConnectPolicyData PageTo call connector and map request and
GetPolicyConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Policy object

Member policies - GET member policies details

Member Policies API takes Member ID as required, PolicyID. Effective and End date as optional parameters to fetch policy details. Based on parameters passed to request – it will return results.

  • If MemberID and PolicyID both are passed, then request will return details of requested policy.
  • If only MemberID is passed, then it will get details of all policies Member has.

Pega Foundation for Healthcare provides connector data pages which invoke the external system REST service using endpoint URL. Below are key rules:

URL format

https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/members/{memberID}/memberPolicies/{PolicyID}

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Policy

memberPoliciesConnect REST
GetMemberPoliciesActivityMethod in REST service to get policy details
MapFromPolicyData TransformMap results from PFHC Policy to API Integration
D_ConnectMemberPolicies D_ConnectMemberPoliciesByIDData PageTo call connector and map request and response
MemberPolicies MemberPoliciesByIDConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Policy object

Provider Contracts - GET contract details

This connector rule takes Provider Contract ID as required and Effective, End date as optional parameters. Based on Provider Contract ID match – it will return the contract details including Network and rate sheet IDs.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/providercontracts /{ID}

Parameters

Key rules

Rule NameRule TypeUsage
providercontractsConnect RESTREST service rule that identifies the path, parameters, and
GetProviderContractsActivityMethod in REST service to get Provider Contract details
MapFromProviderContractData TransformMap results from PFHC Provider Contract to API Integration object
D_ConnectProviderContractData PageTo call connector and map request and response
ProviderContractsConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Provider Contract object

Claims - GET claim

Get Claim service takes Claim ID as input path parameter and returns the claim object in JSON format.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/GetClaims

Parameters

This request takes ‘QueryString’ as parameter in format as

[patient.firstName='BOB' AND provider.name='Ian' AND claim.diagnosisType=55 OR (policy.type = 'EMP')]

Key rules

Rule NameRule TypeUsage
GetClaimsConnect RESTREST service rule that identifies the path, parameters, and methods
GetClaimsActivity

Method in REST service to get array of claims for the matched criteria

MapRequestClaimHistoryDataData TransformMap results from PFHC Provider Contract to API
GetClaimsHistoryBasedOnQueryConnect RESTCall REST Service using endpoint URL
MapResponseClaimHistoryDataData TransformTo map service request data

Claims - POST claim

This connector rule takes claim JSON data as a required parameter and returns a claim ID in JSON. HCIF provides a Pega-provided connect rule, which invokes the external system REST service using an endpoint URL. Below are key rules:

URL format

POST https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/Claims

Output

{

"claimID": "CML-123"

}

Key rules

Rule NameRule TypeUsage
PostClaimConnectCall REST Service using endpoint URL
MapFromClaimWorkWrapperDataMap results from HCIF claims object to API Integration

Employer group contract - GET employer group contract details

Employer Group Contract API takes ID as required field to fetch details. Foundation provides OOTB connector data page which invokes the external system REST service using endpoint URL. Below are key rules:

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/Contracts/{ID}

Parameters

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-Contract
ContractsConnect REST
GetContractsActivityMethod in REST service to get Employer Group Contracts details
MapContractDataData TransformMap results from PFHC Contract to API
D_ConnectContractData PageTo call connector and map request and
GetContractConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Contract object

Member APIs

There are two resources for Member API:

  • Get Member Details
  • Get Member Networks

Both services take Member ID as parameter and returns relative details in data page. Foundation provides OOTB connector data pages which invokes the external system REST service using endpoint URL. Below are key rules:

Members - GET member details

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/members/{ID}

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Member

membersConnect REST
GetMemberActivityMethod in REST service to get Member details
MapFromMemberData TransformMap results from PFHC Member to API
D_ConnectMemberData PageTo call connector and map request and
GetMemberConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Member object

Members - GET members policy networks

URL format

GET

https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/members/{ID}/memberPolicies/{policyID}/networks

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Network

membersConnect REST
GetMemberActivityMethod in REST service to get Member details
GetMemberNetworksActivityMethod in REST service to get Member’s
MapFromNetworkData TransformMap results from PFHC Network to API
D_ConnectMemberNetworksData PageTo call connector and map request and
MemberNetworksConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapNetworkResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Network object

Networks - GET network details

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/networks/{ID}

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Network

networksConnect REST
GetNetworkAPIActivityMethod in REST service to get Network details
MapFromNetworkData TransformMap results from PFHC Network to API
D_ConnectNetworkData PageTo call connector and map request and
GetNetworkConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Network object

Payers - GET payer details

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/payers/{ID}

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Payer

payersConnect REST
GetPayerAPIActivityMethod in REST service to get Payer details
MapFromPayerData TransformMap results from PFHC Payer to API Integration
D_ConnectPayerData PageTo call connector and map request and
GetPayerConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Payer object

Plan details - GET plan details

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/plans

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Plan

plansConnect REST
GetPlanDetailsAPIActivityMethod in REST service to get Plan details
MapFromPlanData TransformMap results from PFHC Plan to API Integration
MapFromBenefitDefinitionData TransformMap results from PFHC Benefit Definition to API Integration object
MapFromBenefitCoverageData TransformMap results from PFHC Benefit Coverage to API Integration object
D_ConnectGetPlanDetailsData PageTo call connector and map request and
GetPlanDetailsConnect RESTCall REST Service using endpoint URL
MapPlanRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Plan object
MapToEntity (PegaHC-Int-Benefit- Definition)Data TransformMap results to PFHC Benefit Definition object
MapToEntity(PegaHC-Int-Benefit- Coverage)Data TransformMap results to PFHC Benefit Coverage object

Plan networks - GET plan networks

This connector rule takes Plan ID as required and Effective, End date as optional parameters. Based on plan’s network – it will return the network details.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/plans/{ID}/{ Resource}

Note: Here Resource is passed as ‘Networks’ for End point URL.

Parameters

Key rules

Rule NameRule TypeUsage
plansConnect RESTREST service rule that identifies the path, parameters, and methods
GetPlanAPIActivityMethod in REST service to get Plan’s Network
MapFromNetworkData TransformMap results from PFHC Network to API
D_ConnectPlanNetworksData PageTo call connector and map request and
PlanNetworksConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapNetworkResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Network object

Providers APIs

The following are the resources provided for Provider API:

  • Get Provider Details
  • Get Provider Networks

Pega Foundation for Healthcare provides connector data pages which invoke the external system REST service using endpoint URL. Below are key rules:

Providers - GET provider details

This connector rule takes NPI ID as required and TIN, Effective, End date as optional parameters to fetch provider details. For Provider – all details including Provider demographic, Provider Affiliations will be returned to data page.

If TIN is passed, then it will return only matching TIN details in Provider Affiliations.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/Provider/{ID}

Parameters

Key rules

Rule NameRule TypeUsage
ProviderConnect RESTREST service rule that identifies the path, parameters, and
GetProviderActivityMethod in REST service to Provider details
MapFromProviderData TransformMap results from PFHC Provider to API Integration object
D_ConnectProviderData PageTo call connector and map request and response
GetProviderConnect RESTCall REST Service using endpoint URL
MapRequestDataData TransformTo map service request data
MapResponseDataData TransformTo map result data to data page
MapToEntityData TransformMap results to PFHC Provider object

Providers - GET provider networks

This connector rule takes NPI ID as required and TIN, Effective, End date as optional parameters to fetch provider details. For Provider – all details including Provider demographic, Provider Affiliations will be returned to data page.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/provider/{ID}/{Resource}

Note: Here Resource is passed as ‘Networks’ for End point URL.

Parameters

Key rules

Rule NameRule TypeUsage
ProviderConnect RESTREST service rule that identifies the path, parameters,
GetProviderActivityMethod in REST service to get Provider details
GetProviderNetworksActivityMethod in REST service to get Provider’s Network
MapFromNetworkDataMap results from PFHC Network to API Integration
D_ConnectProviderNetworksData PageTo call connector and map request and response
ProviderNetworksConnectCall REST Service using endpoint URL
MapRequestDataDataTo map service request data
MapNetworkResponseDataDataTo map result data to data page
MapToEntityDataMap results to PFHC Network object

Rate sheets - GET rate sheet details

This connector rule takes Rate Sheet ID as required and Effective, End date as optional parameters and returns the Rate sheet details in data page.

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/ratesheets/{ID}

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-RateSheet

D_ConnectRateSheetData PageTo call connector and map request and response
RateSheetConnect RESTCall REST Service using endpoint URL
MapRequestDataDataTo map service request data
MapResponseDataDataTo map result data to data page
MapToEntityDataMap results to PFHC Rate Sheet object

Accumulators - GET accumulators

Accumulators API takes accumTypeID, accumStartDate, accumTermDate and accumStatus as required parameters to fetch details and accumType, subtype, network and secondaryID as optional parameters. Below are key rules:

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/accumulators/{accumTypeID}/{accumStartDate}/{accumTermDate}/{accumStatus}

Parameters

Key rules

Rule NameRule TypeUsage

Class: PegaHC-Int-Accumulators-Header

accumulatorsConnect REST
GetAccumulatorsActivityMethod in REST service to get Accumulator
MapFromAccumulatorData TransformMap results from PFHC Accumulators to API Integration object

Plan catalog - GET Plan search results

Plan catalog API takes JSON request as shown below, also listed are other key rules:

URL format

GET https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/PlanCatalog

Parameters

The incoming data is a JSON formatted stream that is mapped to a Page property on the clipboard.

Request Structure

Property Name Property TypeApplies to class Page class
PlanCatalog_RequestPagePegaHC-API

PegaHC-Int-

PlanCatalog_Request

RequestParametersPage ListPegaHC-Int- PlanCatalog_RequestEmbed-PegaHC-Stringlist

RequestParameters would take Name and Value as properties to send the request.

Sample JSON request:

{"RequestParameters":[{"Name":"Category","Value":"Med"},{"Name":"Version" ,"Value":"01"}]}

Similarly, above request can be extended to PlanID, Plan Name, Effective date, End Date, Status, LOB, PlanType.

Response structure

Property Name Property Type Applies to class Page class
PlanCatalog_ResponsePagePegaHC-APICode-Pega-List

Key rules

Rule NameRule TypeUsage

Plan Catalog Request Class: PegaHC-Int-PlanCatalog_Request

Plan Catalog Response Class: Code-Pega-List

PlanCatalogConnect RESTPlan Search REST Service
GetPlanCatalogAPIActivityMethod in REST service to get Plan details
GetPCSPropertyUsingRequestParamDecision TableDecision table to set request parameters to be

Business service API

Claims - GET claim

Get Claim service takes Claim ID as input path parameter and returns the claim object in JSON format.

URL format

Get https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/Claims/{ID}

Parameters

This service rule takes claims id as path parameter and then returns claim object in the form of JSON.

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-Claim
GetClaimAPIService activityMethod in REST service to find claim and return claim details as response
ClaimsService REST

REST service rule that identifies the path, parameters, and methods

Claims - POST (create) claim

Post Claim service rule takes claim JSON as parameter and returns the created Claim ID in JSON format

Parameters

{

"claimID": "CML-123"

}

Parameters

{

"claimID": "CML-123"

}

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-Claim
PostClaimAPIService activityMethod in REST service to create claim and return claimed created as response
ClaimsService REST

REST service rule that identifies the path,

parameters, and methods

Claims - PUT (update) claim

PUT claim service rule takes claim json as parameter and then returns updated claim ID in the form of json.

URL format

PUT https://[hostname:port]/prweb/PRRestService/healthcareapi/v1/Claims

Output

{

"claimID": "CML-123"

}

Key rules

Rule NameRule TypeUsage
Class: PegaHC-Int-Claim
PutClaimAPIService activityMethod in REST service to create claim and return claimed created as response
ClaimsService RESTREST service rule that identifies the path, parameters, and methods
  • Previous topic FHIR API technical specification guide
  • Next topic Pega Foundation for Healthcare X12 message processing tech note

Have a question? Get answers now.

Visit the Support Center to ask questions, engage in discussions, share ideas, and help others.

Did you find this content helpful?

Want to help us improve this content?

We'd prefer it if you saw us at our best.

Pega.com is not optimized for Internet Explorer. For the optimal experience, please use:

Close Deprecation Notice
Contact us