Healthcare restrictions limit access and increase cost

MedX is a censorship resistant protocol for launching medical dApps that connect patients and physicians worldwide for medical care.

Centralized companies that control the storage and transfer of patient health information face costly and lengthy compliance burdens. As a “bulletin board” directly connecting patients with physicians, MedX powered dApps do not store or control health information and are exempt from these compliance burdens.

  • Borderless

    Obtain a medical diagnosis and recommendation from a global pool of physicians

  • Unstoppable Apps

    MedX dApps run as programmed without central authority or censorship

  • Token Curated Registry

    Verifiers worldwide earn MEDX by curating a decentralized registry of physicians

Cross-border telemedicine

Global differences in physician salaries and administrative fees result in vastly different costs of healthcare.

MedX Protocol creates a global market for healthcare where patients have access to an international supply of physicians at a fraction of US healthcare costs.

powered by MedX

OpenCare is a global telemedicine platform that directly connects patients to physicians for medical care anywhere in the world.

As a decentralized application, OpenCare uses Ethereum smart contracts, IPFS for decentralized cloud storage and client-side encryption for medical information.

Try OpenCare

  • Health Insurance DAO
  • Encrypted Messaging
  • OpenCare (Completed)
  • Malpractice Insurance DAO
  • Prescriptions
  • Telemedicine

What will you build?

OpenCare is the first dApp built on the MedX Protocol.

With open access to the MedX Physician Registry, any 3rd party company or developer is free to launch their own unstoppable medical dApps. Join our Telegram to discuss your healthcare idea!

Join Telegram

A token curated registry (TCR)
of physicians

A TCR is a decentrally maintained list judiciously curated by token holders in exchange for economic rewards.

MedX Protocol is an original TCR model and will be the first decentralized global network of physicians. All MedX powered dApps will access the TCR for an instant pool of licensed physicians.

Test MedX TCR
  • MedX Physician Registry

     via API key, dApps can access the MedX registry
     to call physicians from a specific specialty or
     region to connect directly with patients.

    import 'medcredits-solidity/DoctorRegistry.sol';

    contract CaseFactory {
    uint8 constant DERMATOLOGY_CODE = 0x00001a83;

    Case[] cases;
    mapping (uint256 => address) public caseIndices;
    DoctorRegistry doctorRegistry;

    function CaseFactory(DoctorRegistry _doctorRegistry)  {
      doctorRegistry = _doctorRegistry;

    modifier isQualified(address _doctor) {
      return doctorRegistry.isQualified(_doctor, DERMATOLOGY_CODE, 'doctor is not qualified');

    function createCase(
      address _patient,
      address _doctor
     ) external isQualified(_doctor) returns (Case) {
      Case case = new Case(_patient, _doctor);
      uint256 index = cases.length;
      caseIndices[index] = case;
      return case;

  • DApp Autonomous Agent

     dApps can autonomously govern themselves via smart
     contracts. This allows doctors to maintain checks
     and balances by challenging their peers

    contract ChallengeManager is Ownable, Initializable {

    using RegistryLookup for Registry;

     Registry registry;

    event ChallengeDoctorSet(address indexed _case, address indexed _patient, address indexed_challengingDoctor, bytes doctorEncryptedKey);
    event CaseChallenged(address indexed _case, address indexed _patient, address indexed_challengingDoctor);

    function challengeWithDoctor(address _caseAddress, address _doctor, bytes _doctorEncryptedKey)
      Case _case = Case(_caseAddress);
      setChallengingDoctor(_case, _doctor, _doctorEncryptedKey);
      emit CaseChallenged(_caseAddress, _case.patient(), _doctor);

    function setChallengingDoctor(Case _case, address _doctor, bytes _doctorEncryptedKey)
      _case.setDoctorEncryptedCaseKeys(_doctor, _doctorEncryptedKey);
      registry.caseManager().addDoctorToDoctorCases(_doctor, _case);
      registry.caseStatusManager().addOpenCase(_doctor, _case);
      emit ChallengeDoctorSet(_case, _case.patient(), _doctor, _doctorEncryptedKey);

  • Client Side Encryption

     Patient controlled HIPAA compliant client side encryption
     and distributed storage on IPFS of medical information.

    import { ipfsStorage } from 'medcredits'

    async function getCaseDetails (ipfsHash, encryptionKey) {
    const detailsJson = await ipfsStorage.downloadJson(ipfsHash, encryptionKey)
    const details = JSON.parse(detailsJson)
    const [firstImageDataUrl, secondImageDataUrl] = await Promise.all([
      ipfsStorage.downloadImage(details.firstImageHash, props.caseKey),
      ipfsStorage.downloadImage(details.secondImageHash, props.caseKey)

    return {

Putting it all together

MedX is the first global network of physicians that allows an open market for healthcare. Applications on the MedX protocol can be used to eliminate intermediaries and international barriers to affordable care.

OpenCare, the first dApp on MedX, is an international “bulletin board” for telemedicine that reduces the global cost differences in medical care to connect patients to a worldwide supply of physicians.

MedX Technology Stack

  • Application Layer

    Launch any unrestricted healthcare application in the MedX Health System.

  • Protocol Layer

    A global registry of physicians curated by economically incentivized MEDX token holders.

  • Blockchain Layer

    The MedX Protocol employs smart contracts and is secured on the Ethereum blockchain for maximal decentralization.


Join Whitelist

Join Mailing List