Use Case: E-Prescribing
Drug Interaction Checking for E-Prescribing Systems
Meet ONC certification requirements for drug interaction checking. Add FDA-sourced, severity-scored DDI alerts to your e-prescribing workflow with a single REST API call.
Meet ONC certification requirements for drug interaction checking. Add FDA-sourced, severity-scored DDI alerts to your e-prescribing workflow with a single REST API call.
The Office of the National Coordinator for Health IT (ONC) establishes certification criteria for electronic health record technology used in federally funded programs. Drug interaction checking is not optional for certified e-prescribing systems -- it is a specific certification requirement.
ONC certification criterion 170.315(a)(4) requires that certified health IT modules automatically and electronically check for potential interactions when a medication is ordered or prescribed. Specifically, the system must:
The CMS Promoting Interoperability Program (formerly Meaningful Use) requires eligible hospitals and clinicians to use certified EHR technology that meets ONC criteria. For e-prescribing, this means the prescribing module must include drug interaction checking that meets 170.315(a)(4). Failure to meet these requirements can result in payment adjustments under Medicare and Medicaid programs.
Multiple states have enacted electronic prescribing mandates that require prescribers to transmit prescriptions electronically. Several of these mandates include provisions requiring e-prescribing systems to incorporate clinical decision support, including drug interaction checking. As states continue to expand e-prescribing requirements, having a reliable drug interaction API becomes increasingly important for compliance.
RxLabelGuard provides the drug interaction data layer that your e-prescribing system needs to satisfy ONC requirements. The API accepts a list of medications and returns severity-scored interactions with FDA evidence citations. Your e-prescribing system uses this data to render alerts, capture override decisions, and maintain the audit trail required for certification.
Drug interaction checking integrates into the e-prescribing workflow at a critical decision point: after the prescriber selects the medication and dosage, but before the prescription is digitally signed and transmitted to the pharmacy. This placement ensures the prescriber sees interaction alerts while they still have the option to modify or cancel the prescription.
The interaction check must happen before the prescriber signs the prescription. Once signed, the prescription enters the transmission pipeline and modifying it requires a cancellation and re-issue. By checking interactions at the pre-sign stage, the prescriber can make an informed decision while the prescription is still editable.
The RxLabelGuard API is called from your e-prescribing system's backend server, not from the prescriber's browser. Your server collects the patient's medication list, sends it to the API with the new prescription, and returns the interaction data to the frontend for alert rendering. This pattern keeps API keys secure and provides consistent behavior across all client devices.
Surescripts is the dominant electronic prescribing network in the United States, routing prescriptions between prescribers and pharmacies. Understanding how RxLabelGuard fits alongside Surescripts in the e-prescribing stack is important for architecture planning.
RxLabelGuard operates at the application layer, before the prescription enters the Surescripts network. The sequence is:
RxLabelGuard does not interact with the Surescripts network directly. It operates independently as a clinical decision support layer within your application.
Many e-prescribing systems use Surescripts Medication History to obtain a more complete picture of the patient's active medications, including prescriptions filled at other pharmacies. This medication history feed can be combined with the patient's local medication list and sent to the RxLabelGuard API for a more comprehensive interaction check.
By checking the new prescription against both the local medication list and Surescripts medication history, your system catches interactions that would be missed if only checking against the prescriber's own records.
Surescripts offers its own clinical alerting services through partnerships with drug interaction vendors. These services operate within the Surescripts network and may be available through your Surescripts integration. RxLabelGuard is an independent alternative that provides drug interaction checking at the application level, giving you more control over alert presentation, severity thresholds, and the overall user experience.
Integrate drug interaction checking into your e-prescribing system with a single REST call. These examples show production-ready patterns for e-prescribing backends.
Quick test. Replace YOUR_API_KEY with the key from your dashboard.
curl -X POST https://jd6095ijga.execute-api.us-east-2.amazonaws.com/v1/interactions/check \
-H "Content-Type: application/json" \
-H "x-api-key: YOUR_API_KEY" \
-d '{
"drugs": ["methotrexate", "trimethoprim", "omeprazole"],
"format": "structured"
}'A pre-sign interaction check integrated into the e-prescribing workflow.
interface InteractionPair {
drug1: string;
drug2: string;
severity: "contraindicated" | "major" | "moderate" | "minor" | "unknown";
mechanism: string;
recommendation: string;
evidence: { splSetId: string; section: string; snippet: string };
}
interface PreSignCheckResult {
canSign: boolean;
requiresOverride: boolean;
hardStops: InteractionPair[];
alerts: InteractionPair[];
informational: InteractionPair[];
requestId: string;
}
const API_URL =
"https://jd6095ijga.execute-api.us-east-2.amazonaws.com/v1/interactions/check";
async function preSignInteractionCheck(
activeMedications: string[],
newPrescription: string,
apiKey: string
): Promise<PreSignCheckResult> {
const allDrugs = [...activeMedications, newPrescription];
const response = await fetch(API_URL, {
method: "POST",
headers: {
"Content-Type": "application/json",
"x-api-key": apiKey,
},
body: JSON.stringify({ drugs: allDrugs, format: "structured" }),
});
if (!response.ok) {
throw new Error(`RxLabelGuard API error: ${response.status}`);
}
const result = await response.json();
const hardStops = result.pairs.filter(
(p: InteractionPair) => p.severity === "contraindicated"
);
const alerts = result.pairs.filter(
(p: InteractionPair) => p.severity === "major"
);
const informational = result.pairs.filter(
(p: InteractionPair) =>
p.severity === "moderate" || p.severity === "minor"
);
return {
canSign: hardStops.length === 0,
requiresOverride: alerts.length > 0,
hardStops,
alerts,
informational,
requestId: result.requestId,
};
}
// Example: Pre-sign check for a new methotrexate prescription
const check = await preSignInteractionCheck(
["trimethoprim", "omeprazole", "lisinopril"],
"methotrexate",
process.env.RXLABELGUARD_API_KEY!
);
if (!check.canSign) {
// Block signing - contraindicated interaction detected
console.log("Cannot sign:", check.hardStops);
} else if (check.requiresOverride) {
// Require override with documented reason before signing
console.log("Override required:", check.alerts);
} else {
// Safe to proceed with signing
console.log("No critical interactions. Ready to sign.");
}Pre-sign interaction check for Django or FastAPI backends.
import requests
import os
RXLABELGUARD_URL = (
"https://jd6095ijga.execute-api.us-east-2.amazonaws.com"
"/v1/interactions/check"
)
def pre_sign_check(
active_meds: list[str],
new_rx: str,
api_key: str
) -> dict:
"""Run interaction check before prescription signing."""
all_drugs = active_meds + [new_rx]
response = requests.post(
RXLABELGUARD_URL,
headers={
"x-api-key": api_key,
"Content-Type": "application/json",
},
json={"drugs": all_drugs, "format": "structured"},
timeout=10,
)
response.raise_for_status()
result = response.json()
hard_stops = [
p for p in result.get("pairs", [])
if p["severity"] == "contraindicated"
]
major_alerts = [
p for p in result.get("pairs", [])
if p["severity"] == "major"
]
return {
"can_sign": len(hard_stops) == 0,
"requires_override": len(major_alerts) > 0,
"hard_stops": hard_stops,
"major_alerts": major_alerts,
"all_interactions": result.get("pairs", []),
"request_id": result.get("requestId"),
}
# Example: Check before signing an e-prescription
result = pre_sign_check(
active_meds=["trimethoprim", "omeprazole", "lisinopril"],
new_rx="methotrexate",
api_key=os.environ["RXLABELGUARD_API_KEY"],
)
if not result["can_sign"]:
print("BLOCKED: Contraindicated interaction detected")
elif result["requires_override"]:
print("OVERRIDE REQUIRED: Major interaction detected")For complete API documentation including error codes and advanced parameters, see the Check Interactions endpoint reference.
If you are building or certifying an e-prescribing system under ONC 170.315(a)(4), here is how the RxLabelGuard API supports each requirement. Your system must implement the user interface and audit logging; the API provides the interaction data.
Send the patient's active medications + new prescription to POST /v1/interactions/check. The API automatically checks all pairwise combinations and returns detected interactions.
Trigger the API call when a prescription is created. Collect the patient's active medication list from your database.
The API returns severity, mechanism, recommendation, and evidence citation for each detected interaction. Severity levels map directly to alert types.
Render the alert UI based on the API response. Map severity to alert intrusiveness (hard stop, modal, notification).
The API response includes a requestId that uniquely identifies the interaction check. Store this with the override reason for audit purposes.
Implement the override workflow UI. Capture and store the prescriber's override reason alongside the requestId.
Each API response includes a requestId, the full list of detected interactions, severity levels, and FDA evidence citations. This data forms the foundation of your audit trail.
Store the API response, prescriber decisions (override, modify, cancel), and timestamps. Make this data available for regulatory review.
RxLabelGuard derives interaction data from FDA Structured Product Labeling, a publicly verifiable authoritative source. Every interaction includes the SPL Set ID and label section for independent verification.
Document your data source in your certification materials. Reference FDA SPL as the underlying data source.
Electronic Prescribing for Controlled Substances (EPCS) adds additional regulatory requirements beyond standard e-prescribing. The DEA's EPCS regulations (21 CFR Part 1311) require identity proofing, two-factor authentication, and specific audit trail requirements for controlled substance prescriptions.
Drug interaction checking is particularly important in the EPCS workflow because controlled substances are frequently involved in dangerous drug interactions. Opioid-benzodiazepine combinations, for example, carry FDA boxed warnings about the risk of respiratory depression and death.
EPCS regulations require detailed audit trails for every controlled substance prescription. The RxLabelGuard API response includes a unique requestId that can be stored alongside the EPCS audit record. This links the interaction check to the specific prescription event, providing a complete chain of evidence from interaction detection through prescriber decision to prescription transmission.
Start free during development and certification testing. Scale to production without enterprise procurement.
Development and certification testing
Pilot e-prescribing deployments
Production e-prescribing workloads
All tiers include structured JSON responses, severity scoring, and FDA evidence citations. No hidden fees.
View full pricing details and feature comparisonYes. ONC Health IT Certification criteria (specifically criterion 170.315(a)(4)) require certified health IT modules to check for drug-drug interactions when a medication is ordered or prescribed. The system must automatically check the prescribed medication against the patient's active medication list and display any detected interactions to the prescriber.
RxLabelGuard provides the drug interaction data layer that e-prescribing systems need to satisfy ONC 170.315(a)(4). The API checks drug pairs against FDA label data and returns severity-scored interactions with evidence citations. Your e-prescribing system uses this data to display alerts at the point of prescribing, meeting the certification requirement for automated DDI checking.
RxLabelGuard operates independently of the Surescripts network. Your e-prescribing system calls the RxLabelGuard API to check interactions before transmitting the prescription via Surescripts. The interaction check happens in your application layer, not in the Surescripts transmission pipeline. This means RxLabelGuard works with any e-prescribing system regardless of which prescription routing network it uses.
The API returns five severity levels: contraindicated (must not use together), major (potentially life-threatening), moderate (may require monitoring), minor (minimal clinical significance), and unknown (insufficient data). E-prescribing systems typically display interruptive alerts for contraindicated and major interactions, and non-interruptive notifications for moderate interactions.
Yes. The API checks interactions for all drugs with FDA labels, including Schedule II-V controlled substances. When an e-prescribing system processes an EPCS prescription, it can call the RxLabelGuard API to check the controlled substance against the patient's medication list before the prescription is digitally signed and transmitted. This adds a safety layer to the already-rigorous EPCS workflow.
Adding drug interaction checking to your e-prescribing system typically takes a few hours of development. Follow these steps to integrate and prepare for ONC certification testing.
Sign up at rxlabelguard.com/register. No credit card required for the Sandbox tier. The free tier provides 50 requests/month, enough for development and initial certification testing.
Verify your integration with well-documented interactions: warfarin + aspirin, methotrexate + trimethoprim, simvastatin + clarithromycin. Confirm severity levels and evidence citations match expected clinical data. See the API documentation for complete schemas.
Add the interaction check after medication selection but before prescription signing. Collect the patient's active medication list from your database, combine with Surescripts medication history if available, and send the full list to the API. Handle timeouts gracefully with a fallback that logs the check failure.
Build the alert rendering based on severity levels. Hard stops for contraindicated, interruptive modals for major, informational panels for moderate. Implement the override workflow with reason capture. See our alert fatigue guide for clinical UX best practices.
Store every API response (requestId, interactions detected, severity levels) alongside prescriber decisions (alert acknowledged, override reason, prescription modified/cancelled). This data is required for ONC certification testing and ongoing regulatory compliance.
Test the full workflow against ONC 170.315(a)(4) test procedures. Verify that interactions are detected, alerts displayed, overrides captured, and audit trail complete. Upgrade to Developer or Professional from your dashboard for production volumes.
Guides and documentation for e-prescribing integration.
Detailed guide to integrating drug interaction checking into EHR systems and CPOE workflows.
How pharmacy management systems integrate drug interaction checking at dispensing.
How five-level severity classification reduces alert override rates.
Step-by-step tutorial for building drug interaction checks into your application.
Details on the free Sandbox tier with full structured output.
Side-by-side comparison of RxLabelGuard, openFDA, DrugBank, and enterprise vendors.
Create a free account, generate an API key, and start testing for ONC certification in under five minutes. No sales calls, no credit card required.
Already have an account? Go to your dashboard
Medical Disclaimer
This information is derived from FDA Structured Product Labeling and is provided for informational purposes only. It should not be used as a substitute for professional medical advice, diagnosis, or treatment. Always consult a qualified healthcare provider before making clinical decisions. RxLabelGuard provides drug interaction data for integration into clinical decision support systems and is not a substitute for clinical judgment.