E-Prescription & Electronic Prescription Regulations in Indonesia: A Practical Compliance Guide for Healthcare Facilities
N
Back to Blog

E-Prescription & Electronic Prescription Regulations in Indonesia: A Practical Compliance Guide for Healthcare Facilities

Regulasi & Compliance
Nugroho Setiawan · Konsultan IT & Full Stack Developer 11 May 2026 13 min baca 2,988 kata 557 views
Implementing e-prescriptions and electronic prescriptions in Indonesia requires strict regulatory compliance. This article provides a comprehensive guide for IT managers, clinic owners, and decision-makers to ensure your system complies with the latest Ministry of Health regulations and the SatuSeha

In Indonesia's continuously evolving healthcare landscape, the adoption of digital technology is inevitable. One crucial innovation is the use of electronic prescriptions or e-prescriptions. However, this transition is not without complexity, especially regarding regulations and interoperability standards. For hospital IT managers, clinic owners, and operational managers, understanding the ins and outs of the Minister of Health Regulation (PMK) regarding e-prescriptions and their integration with the Ministry of Health's SatuSehat platform is no longer an option, but an absolute necessity. Non-compliance not only risks legal sanctions, but also hinders operational efficiency and the quality of patient care. This article serves as a practical and in-depth guide, outlining the regulatory framework, technical implementation standards, and code examples that you can apply. We will discuss concrete steps to ensure your health information system (SIMRS or SIM Klinik) is fully compliant, secure, and ready to face the future of Indonesian healthcare digitalization. Let us delve into the details so that your healthcare facility can operate optimally and in accordance with applicable regulations.

Basic Concepts of E-Prescriptions and the Regulatory Framework in Indonesia

An e-prescription, or electronic prescription, is a prescription that is created, signed, and sent electronically by a doctor to a pharmacy or other healthcare facility. Unlike manual prescriptions written on paper, e-prescriptions utilize information systems to improve accuracy, security, and efficiency. In Indonesia, the main legal basis governing e-prescriptions is Minister of Health Regulation (PMK) Number 24 of 2022 concerning Medical Records, which explicitly states that medical records can be created electronically and include prescriptions. Then, PMK Number 26 of 2023 concerning Healthcare Facilities also reinforces the obligation for healthcare facilities (fasyankes) to implement electronic medical records (RME) integrated with the SatuSehat platform.

This regulation requires every healthcare facility, from community health centers, clinics, to hospitals, to implement RME that includes an electronic prescription module. The main goal is to create an integrated and interoperable national health data ecosystem through the SatuSehat platform. With SatuSehat, patient prescription data can be exchanged securely and efficiently between healthcare facilities, pharmacies, and even the patients themselves through personal applications. This is a significant step forward to reduce prescription errors, improve drug availability, and facilitate more coordinated healthcare services.

In practice, an e-prescription must meet several important criteria: authenticity (created by an authorized doctor), integrity (cannot be modified after signing), confidentiality (access limited to authorized parties), and availability (accessible whenever needed). A concrete example: a doctor at Hospital X using a SatuSehat-integrated SIMRS will write a prescription in the system. After being reviewed and signed electronically (with an electronic certificate or other strong authentication method), the prescription will automatically be sent to the pharmacy chosen by the patient or a pharmacy within the hospital. This prescription data is then recorded in the patient's RME and simultaneously sent to the SatuSehat platform, ensuring the patient's treatment history is always up-to-date and can be accessed by other authorized medical personnel if needed.

Integration with SatuSehat is not just about data transmission, but also about standardization. This platform adopts the FHIR (Fast Healthcare Interoperability Resources) Release 4 (R4) standard from HL7, which is the global standard for health data exchange. This means your SIMRS or SIM Klinik must be able to produce and consume data in FHIR R4 format to ensure full compatibility. Understanding this regulation is the first and most crucial step for every healthcare facility to ensure their health information system is not only modern, but also fully legally compliant and ready to face the era of digital health.

Technical Implementation of a Compliant E-Prescription System

Ensuring your e-prescription system is compliant requires a deep technical understanding of integration and data standards. The main foundation is the ability of your hospital information system (SIMRS) or clinic information system (SIM Klinik) to interact with the SatuSehat platform using the FHIR R4 standard. We recommend using a stable programming language and a mature framework, such as PHP with Laravel 11.x or JavaScript with Node.js 20 LTS, as the main backend. For the database, PostgreSQL 16 is an excellent choice due to its reliability, scalability, and JSONB support that facilitates storing FHIR data.

The integration process begins with authentication. SatuSehat uses the OAuth2 Client Credentials Grant authorization model. Your system must be able to generate a valid access token (JWT) for each API request. After successful authentication, the next step is to map the prescription data from your internal SIMRS/SIM Klinik database into the FHIR R4 resource structure. The key resources relevant for e-prescriptions include Patient, Practitioner, Organization, Medication, and MedicationRequest. Ensure that data such as patient ID, NIK, doctor's name, drug name, dosage, frequency, and route of administration are correctly mapped to the appropriate FHIR elements.

For the bridging process to SatuSehat, you will often interact with endpoints such as /MedicationRequest to send new prescriptions. It is important to ensure that the JSON payload you send is valid according to the FHIR R4 schema. In addition, you need to handle the universal IDs used by SatuSehat, such as the ID of a patient registered on the platform. This usually requires an initial patient registration process to SatuSehat, which will return a unique ID that must be stored and used by your SIMRS/SIM Klinik for every subsequent transaction.

The data security aspect is non-negotiable. All communication between your SIMRS/SIM Klinik and SatuSehat must be encrypted using SSL/TLS (at least TLS 1.2). Sensitive patient data, even when stored in your local database, should be encrypted using standards such as AES-256. The key modules in the SIMRS/SIM Klinik involved in e-prescriptions include the doctor module for writing prescriptions, the pharmacy module for verification and dispensing, and the medical records module for historical recording. Ensure that each of these modules has strong data validation to prevent invalid or incomplete entries. With the right infrastructure and technical practices, healthcare facilities can build an e-prescription system that is not only efficient but also fully compliant with SatuSehat's regulations and interoperability standards.

Example Code for Implementing FHIR Bridging to SatuSehat

Integration with SatuSehat requires handling authentication tokens and constructing accurate FHIR payloads. The following is an example implementation using PHP with the Laravel 11.x framework, utilizing the Guzzle HTTP Client for ease of API interaction. Make sure you have installed Guzzle (composer require guzzlehttp/guzzle).

1. Getting an Access Token from SatuSehat

The first step is to obtain an OAuth2 access token. This token is required for every API request to SatuSehat. You must have a client_id and client_secret obtained from registering your application on the SatuSehat Developer Portal.

<?php namespace App\Services; use GuzzleHttp\Client; use Illuminate\Support\Facades\Cache; class SatuSehatAuthService { protected $client; protected $clientId; protected $clientSecret; protected $authUrl; public function __construct() { $this->client = new Client(); $this->clientId = env('SATUSEHAT_CLIENT_ID'); $this->clientSecret = env('SATUSEHAT_CLIENT_SECRET'); $this->authUrl = env('SATUSEHAT_AUTH_URL', 'https://api-satusehat.kemkes.go.id/oauth2/v1/accesstoken'); } public function getAccessToken(): ?string { return Cache::remember('satusehat_access_token', now()->addMinutes(59), function () { try { $response = $this->client->post($this->authUrl, [ 'form_params' => [ 'client_id' => $this->clientId, 'client_secret' => $this->clientSecret ], 'headers' => [ 'Content-Type' => 'application/x-www-form-urlencoded' ] ]); $data = json_decode($response->getBody()->getContents(), true); return $data['access_token'] ?? null; } catch (\Exception $e) { \Log::error("Failed to get SatuSehat access token: " . $e->getMessage()); return null; } }); } }

The code above shows how to make a POST request to the SatuSehat authorization endpoint. client_id and client_secret must be stored in your environment variables (.env) for security. The token will be stored in the Laravel cache for 59 minutes to avoid unnecessary repeated requests, considering that the token is usually valid for 60 minutes. Error handling is also included for logging in case of failure.

2. Sending MedicationRequest to SatuSehat

After obtaining the token, you can use it to send FHIR resources, for example MedicationRequest. Make sure you already have the patient, practitioner, and organization IDs registered with SatuSehat.

<?php namespace App\Services; use GuzzleHttp\Client; class SatuSehatService { protected $client; protected $baseUrl; protected $authService; public function __construct(SatuSehatAuthService $authService) { $this->client = new Client(); $this->baseUrl = env('SATUSEHAT_API_URL', 'https://api-satusehat.kemkes.go.id/fhir-r4/v1'); $this->authService = $authService; } public function sendMedicationRequest(array $medicationRequestData): ?array { $accessToken = $this->authService->getAccessToken(); if (!$accessToken) { return ['error' => 'Failed to get access token.']; } try { $response = $this->client->post("{$this->baseUrl}/MedicationRequest", [ 'headers' => [ 'Authorization' => "Bearer {$accessToken}", 'Content-Type' => 'application/fhir+json' ], 'json' => $medicationRequestData ]); return json_decode($response->getBody()->getContents(), true); } catch (\GuzzleHttp\Exception\ClientException $e) { $responseBody = $e->getResponse()->getBody()->getContents(); \Log::error("SatuSehat MedicationRequest error: " . $responseBody); return ['error' => 'Client error', 'details' => json_decode($responseBody, true)]; } catch (\Exception $e) { \Log::error("Failed to send MedicationRequest: " . $e->getMessage()); return ['error' => 'General error', 'details' => $e->getMessage()]; } } }

The sendMedicationRequest function accepts an array $medicationRequestData containing a structured FHIR JSON payload. It is important to set the Authorization header with a bearer token and Content-Type as application/fhir+json. Error handling is prepared to catch ClientException from Guzzle, which often occurs if there is a validation problem with the payload or incorrect authorization. This implementation ensures that every request to SatuSehat is made with the correct protocol and adequate security.

Payload and Error Handling in SatuSehat Integration

The success of e-prescription integration with SatuSehat depends heavily on the accuracy of the FHIR payload sent and the robustness of error handling. Each FHIR resource has a specific structure, and even a slight mismatch can cause rejection by the API. Below is an example of a realistic JSON payload for the MedicationRequest resource, which describes a prescription for a patient with a specific ID, prescribed by a specific practitioner, and for a specific medication.

{  "resourceType": "MedicationRequest",  "id": "medreq-example-01",  "identifier": [    {      "system": "http://sys-klinik.id/medicationrequest",      "value": "MR-20230515-001"    }  ],  "status": "active",  "intent": "order",  "medicationReference": {    "reference": "Medication/100000000000000004",    "display": "Paracetamol 500 mg Tablet"  },  "subject": {    "reference": "Patient/100000000000000001",    "display": "Budi Santoso"  },  "encounter": {    "reference": "Encounter/100000000000000002"  },  "authoredOn": "2023-05-15T10:00:00+07:00",  "requester": {    "reference": "Practitioner/100000000000000003",    "display": "Dr. Siti Aminah"  },  "dosageInstruction": [    {      "sequence": 1,      "text": "1 tablet 3 kali sehari setelah makan",      "timing": {        "repeat": {          "frequency": 3,          "period": 1,          "periodUnit": "d"        }      },      "route": {        "coding": [          {            "system": "http://terminology.hl7.org/CodeSystem/v3-RouteOfAdministration",            "code": "PO",            "display": "Peroral"          }        ]      },      "doseAndRate": [        {          "type": {            "coding": [              {                "system": "http://terminology.hl7.org/CodeSystem/dose-rate-type",                "code": "ordered",                "display": "Ordered"              }            ]          },          "doseQuantity": {            "value": 1,            "unit": "tablet",            "system": "http://unitsofmeasure.org",            "code": "{tablet}"          }        }      ]    }  ],  "dispenseRequest": {    "numberOfRepeatsAllowed": 0,    "quantity": {      "value": 30,      "unit": "tablet",      "system": "http://unitsofmeasure.org",      "code": "{tablet}"    }  }}

The payload above shows the details of the medication, patient, practitioner, dosage, and dispensing instructions. Each reference (for example Patient/1000...) refers to a resource that already exists or has been created in SatuSehat. Common errors often occur in this part, for example an invalid reference ID, an incorrect date format, or an unrecognized terminology code.

When an error occurs, the SatuSehat API will return an error response. An example of a frequently encountered error response is:

{  "resourceType": "OperationOutcome",  "issue": [    {      "severity": "error",      "code": "processing",      "details": {        "text": "Invalid reference: Patient/100000000000000099. Resource with this ID does not exist or is not accessible."      },      "expression": [        "MedicationRequest.subject"      ]    }  ]}

This error, with HTTP status code 400 Bad Request, indicates that the referenced patient ID (Patient/100000000000000099) was not found or cannot be accessed. Handling this kind of error requires a strong validation mechanism on the side of your SIMRS/SIM Klinik before sending the payload. Ensure that all reference IDs (patient, practitioner, organization, medication) have been registered and are valid in SatuSehat. Handling strategies include: (1) Logging error details comprehensively, (2) Providing clear notifications to users (doctors or pharmacists) about the problem that occurred, (3) Implementing a retry mechanism for temporary errors (for example 5xx Server Error), and (4) Building a local FHIR schema validation mechanism before submission to minimize errors from the API side. With careful handling, data integrity and the smooth operation of e-prescriptions can be maintained.

Best Practices for Compliant E-Prescription Implementation

  1. Understand Regulations Thoroughly: Always refer to official documents such as PMK 24/2022 and PMK 26/2023, as well as technical implementation guidelines from the Ministry of Health. Regulations can change, so ensure your team is always up-to-date with the latest version to avoid non-compliance.
  2. Prioritize Patient Data Security and Privacy: Implement the highest security standards, including end-to-end data encryption (TLS 1.2+), encryption of data at rest (AES-256), and strict role-based access control (RBAC). Ensure your system complies with the principles of confidentiality, integrity, and availability of patient data in accordance with personal data protection regulations.
  3. Perform Thorough Data Validation: Implement data validation on both the client and server sides for all e-prescription inputs, from patient data, doctor data, to drug details. Ensure all reference IDs (for example, SatuSehat patient ID) have been validated and exist before sending the FHIR payload to prevent API errors.
  4. Build a Robust Logging and Monitoring Mechanism: Every e-prescription transaction, including the sending of and response from the SatuSehat API, must be recorded in detail. Set up a proactive monitoring system to detect anomalies, errors, or performance issues in real time, enabling rapid response to incidents.
  5. Plan for Scalability and High Availability: Design your e-prescription system so that it can handle increasing transaction volumes over time without performance degradation. Use an architecture that supports high availability, such as load balancing and database replication, to ensure the service does not stop.
  6. Perform Integration Testing Regularly: Before deployment to the production environment, conduct thorough testing with the SatuSehat sandbox environment. Test various scenarios, including success cases, failure cases, and error handling, to ensure the integration runs smoothly and as expected. Include end-to-end testing from prescription writing to receipt at the pharmacy.
  7. Provide Comprehensive Training to Users: Doctors, nurses, pharmacists, and administrative staff must be adequately trained on how to use the e-prescription system. Training should cover workflows, security features, and procedures for handling common issues to minimize human error and accelerate adoption.
  8. Maintain Interoperability with the FHIR Standard: Always ensure your implementation follows the latest FHIR R4 standard and the profiles defined by the Ministry of Health. Join the SatuSehat developer community to get the latest information and share best practices in development and integration.
  9. Prepare a Disaster Recovery Procedure: Have a clear and tested disaster recovery plan (DRP) for your e-prescription system. This includes regular data backups, restoration strategies, and failover procedures to minimize downtime and data loss in the event of a serious incident.

FAQ about E-Prescription Regulations and Implementation

  1. What is the difference between e-prescription and electronic prescription, and why are both important?
    E-prescription (electronic prescription) is a prescription that is created, signed, and sent digitally. This differs from a manual prescription that is handwritten. Both are important because e-prescription improves prescription accuracy, reduces the risk of writing errors, speeds up the service process at pharmacies, and facilitates the integration of patient medical record data nationally through the SatuSehat platform, in accordance with PMK 24/2022.
  2. How can my healthcare facility's information system be integrated with the SatuSehat platform?
    Integration with SatuSehat requires the development or adaptation of your SIMRS/SIM Klinik so that it can communicate using the FHIR R4 standard. This involves an OAuth2 authorization process to obtain an access token, then mapping your internal data to FHIR resources such as Patient, Practitioner, MedicationRequest, and sending them to the SatuSehat API endpoint. SatuSehat technical documentation and sandbox are very helpful in this process.
  3. What are the main challenges in implementing a compliant e-prescription and how to overcome them?
    Challenges include the complexity of mapping data to the FHIR standard, handling authorization and data security, and ensuring strict data validation. Overcoming them requires a competent technical team, the use of appropriate frameworks and libraries (for example Guzzle for PHP, Axios for Node.js), extensive testing, and an in-depth understanding of the SatuSehat API documentation and related regulations.
  4. How to ensure the security and confidentiality of patient data in the e-prescription system?
    Ensure all data transmission uses the HTTPS protocol with TLS 1.2 or higher. Sensitive data in the database must be encrypted (for example AES-256). Implement role-based access control (RBAC) to limit who can view or modify prescriptions. Audit logs must always be active to track every user activity and ensure compliance with PMK 24/2022 concerning the protection of medical record data.
  5. Are all healthcare facilities required to implement e-prescription and integrate with SatuSehat?
    Based on PMK 24/2022 and PMK 26/2023, all healthcare facilities in Indonesia are required to implement Electronic Medical Records (RME) and integrate with the SatuSehat platform. E-prescription is an integral part of RME. Although there are implementation stages, the direction of regulation is clear toward full digitalization and national interoperability.
  6. What are the consequences if a healthcare facility does not comply with the e-prescription and SatuSehat regulations?
    Non-compliance can result in administrative sanctions, including verbal or written warnings, fines, up to the revocation of the healthcare facility's operating license. In addition, healthcare facilities that are not integrated with SatuSehat may face difficulties in the BPJS Kesehatan claim process in the future and lose access to the national health data ecosystem, which ultimately can harm patients and operations.

The transformation toward e-prescription and integration with SatuSehat is a progressive step that is inevitable in the Indonesian healthcare world. Compliance with regulations is not merely a legal obligation, but also a strategic investment to improve service quality, operational efficiency, and patient data security at your facility. From understanding the regulations PMK 24/2022 and 26/2023 to technical implementation with FHIR R4 using Laravel 11.x or Node.js 20 LTS, every detail requires serious attention. Do not let technical or regulatory complexity hinder the progress of your healthcare facility. Nugroho Setiawan and the team have a proven track record in the development of SIMRS, SIM Klinik, as well as bridging integrators for BPJS, SatuSehat, and FHIR. We are ready to help you build or adapt a system that is fully compliant and optimal. Contact us today for a free consultation and realize a modern and integrated e-prescription system at your healthcare facility.

This article is part of the knowledge base of Nugroho Setiawan, an IT consultant in Jogja (Yogyakarta). Related solutions: SIMRS (Hospital Information System) Clinic Management System SatuSehat Integration. Need a free consultation?

Terakhir diperbarui 18 Oct 2026

Komentar

Komentar ditinjau sebelum tampil.

Belum ada komentar. Jadilah yang pertama!

Butuh bantuan implementasi atau dashboard data?

Saya membantu konsultasi IT, pengembangan aplikasi, dan visualisasi data untuk rumah sakit, klinik, dan bisnis di Yogyakarta (DIY), Magelang, dan sekitarnya.

WhatsApp Jasa Visualisasi Data Demo VizStudio
Produk & Solusi SIMRS ERP Portfolio Konsultasi Gratis