Comment utiliser l'API HL7 FHIR: Guide complet d'intégration du secteur de la santé (2026)

TL;DR

HL7 FHIR (Fast Healthcare Interoperability Resources) est la norme moderne pour l'échange de données de santé, utilisant des API RESTful avec des réponses JSON/XML. Il fournit des ressources standardisées pour les patients, les observations, les médicaments, et plus encore, avec l'authentification OAuth 2.0 et SMART on FHIR pour l'intégration d'applications. Ce guide couvre l'architecture FHIR, les types de ressources, les paramètres de recherche, l'authentification et les stratégies de mise en œuvre en production.

Introduction

La fragmentation des données de santé coûte au système de santé américain 30 milliards de dollars par an. Pour les développeurs d'applications de santé, l'intégration de l'API HL7 FHIR n'est pas facultative — c'est la norme industrielle imposée par le CMS et adoptée par Epic, Cerner et tous les principaux fournisseurs de DSE (Dossiers de Santé Électroniques).

Voici la réalité : les prestataires utilisant des applications compatibles FHIR réduisent le temps de coordination des soins de 40 % et éliminent 85 % des demandes de dossiers basées sur le fax. Une intégration solide de l'API FHIR permet un échange de données fluide entre les DSE, les portails patients et les plateformes de coordination des soins.

Ce guide vous accompagne à travers le processus complet d'intégration de l'API HL7 FHIR. Vous y apprendrez l'architecture FHIR, les types de ressources, les paramètres de recherche, l'authentification OAuth 2.0, l'intégration SMART on FHIR et les stratégies de déploiement en production. À la fin, vous disposerez d'une intégration FHIR prête pour la production.

Qu'est-ce que HL7 FHIR ?

FHIR (Fast Healthcare Interoperability Resources) est un cadre de normes pour l'échange électronique d'informations de santé. Développé par Health Level Seven International (HL7), FHIR utilise des technologies web modernes, notamment les API RESTful, JSON, XML et OAuth 2.0.

Types de Ressources FHIR

FHIR définit plus de 140 types de ressources. Les ressources principales incluent :

Architecture de l'API FHIR

FHIR utilise une structure d'API RESTful :

https://fhir-server.com/fhir/{resourceType}/{id}

Versions de FHIR comparées

Le CMS exige que les DSE certifiés prennent en charge FHIR R4 pour les API d'accès patient et d'accès prestataire.

Démarrage : Accès au Serveur FHIR

Étape 1 : Choisissez votre serveur FHIR

Options de déploiement de serveur FHIR :

Étape 2 : Obtenez les identifiants du serveur

Pour les services FHIR cloud :

# Azure API for FHIR
# 1. Create FHIR Service in Azure Portal
# 2. Configure authentication (OAuth 2.0 or AAD)
# 3. Get FHIR endpoint: https://{service-name}.azurehealthcareapis.com
# 4. Register client app for OAuth

# AWS HealthLake
# 1. Create Data Store in AWS Console
# 2. Configure IAM roles
# 3. Get endpoint: https://healthlake.{region}.amazonaws.com

Étape 3 : Comprendre les Opérations RESTful de FHIR

FHIR prend en charge les méthodes HTTP standard :

Étape 4 : Effectuez votre premier appel FHIR

Tester la connectivité :

curl -X GET "https://fhir-server.com/fhir/metadata" \
  -H "Accept: application/fhir+json" \
  -H "Authorization: Bearer {token}"

Réponse attendue :

{
  "resourceType": "CapabilityStatement",
  "status": "active",
  "date": "2026-03-25",
  "fhirVersion": "4.0.1",
  "rest": [{
    "mode": "server",
    "resource": [
      { "type": "Patient" },
      { "type": "Observation" },
      { "type": "Condition" }
    ]
  }]
}

Opérations FHIR de Base

Lecture d'une Ressource Patient

Récupérer un patient par ID :

const FHIR_BASE_URL = process.env.FHIR_BASE_URL;
const FHIR_TOKEN = process.env.FHIR_TOKEN;

const fhirRequest = async (endpoint, options = {}) => {
  const response = await fetch(`${FHIR_BASE_URL}/fhir${endpoint}`, {
    ...options,
    headers: {
      'Accept': 'application/fhir+json',
      'Authorization': `Bearer ${FHIR_TOKEN}`,
      ...options.headers
    }
  });

  if (!response.ok) {
    const error = await response.json();
    throw new Error(`FHIR Error: ${error.issue?.[0]?.details?.text || response.statusText}`);
  }

  return response.json();
};

// Read patient by ID
const getPatient = async (patientId) => {
  const patient = await fhirRequest(`/Patient/${patientId}`);
  return patient;
};

// Usage
const patient = await getPatient('12345');
console.log(`Patient: ${patient.name[0].given[0]} ${patient.name[0].family}`);
console.log(`DOB: ${patient.birthDate}`);
console.log(`Gender: ${patient.gender}`);

Structure de la Ressource Patient

{
  "resourceType": "Patient",
  "id": "12345",
  "identifier": [
    {
      "use": "usual",
      "type": {
        "coding": [{
          "system": "http://terminology.hl7.org/CodeSystem/v2-0203",
          "code": "MR"
        }]
      },
      "system": "http://hospital.example.org",
      "value": "MRN123456"
    }
  ],
  "name": [
    {
      "use": "official",
      "family": "Smith",
      "given": ["John", "Michael"]
    }
  ],
  "telecom": [
    {
      "system": "phone",
      "value": "555-123-4567",
      "use": "home"
    },
    {
      "system": "email",
      "value": "john.smith@email.com"
    }
  ],
  "gender": "male",
  "birthDate": "1985-06-15",
  "address": [
    {
      "use": "home",
      "line": ["123 Main Street"],
      "city": "Springfield",
      "state": "IL",
      "postalCode": "62701"
    }
  ]
}

Recherche de Ressources

Rechercher des patients par nom :

const searchPatients = async (searchParams) => {
  const query = new URLSearchParams();

  // Add search parameters
  if (searchParams.name) {
    query.append('name', searchParams.name);
  }
  if (searchParams.birthDate) {
    query.append('birthdate', searchParams.birthDate);
  }
  if (searchParams.identifier) {
    query.append('identifier', searchParams.identifier);
  }
  if (searchParams.gender) {
    query.append('gender', searchParams.gender);
  }

  const response = await fhirRequest(`/Patient?${query.toString()}`);
  return response;
};

// Usage
const results = await searchPatients({ name: 'Smith', birthDate: '1985-06-15' });

console.log(`Found ${results.total} patients`);
results.entry.forEach(entry => {
  const patient = entry.resource;
  console.log(`${patient.name[0].family}, ${patient.name[0].given[0]}`);
});

Paramètres de Recherche Courants

Modificateurs de Recherche

Préfixes de Recherche pour les Dates et les Nombres

Travailler avec des Données Cliniques

Création d'une Observation (Signes Vitaux)

Enregistrer les signes vitaux :

const createObservation = async (observationData) => {
  const observation = {
    resourceType: 'Observation',
    status: 'final',
    category: [
      {
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/observation-category',
          code: 'vital-signs'
        }]
      }
    ],
    code: {
      coding: [{
        system: 'http://loinc.org',
        code: observationData.code, // e.g., '8480-6' for Systolic BP
        display: observationData.display
      }]
    },
    subject: {
      reference: `Patient/${observationData.patientId}`
    },
    effectiveDateTime: observationData.effectiveDate || new Date().toISOString(),
    valueQuantity: {
      value: observationData.value,
      unit: observationData.unit,
      system: 'http://unitsofmeasure.org',
      code: observationData.ucumCode
    },
    performer: [
      {
        reference: `Practitioner/${observationData.performerId}`
      }
    ]
  };

  const response = await fhirRequest('/Observation', {
    method: 'POST',
    body: JSON.stringify(observation)
  });

  return response;
};

// Usage - Record blood pressure
const systolicBP = await createObservation({
  patientId: '12345',
  code: '8480-6',
  display: 'Systolic blood pressure',
  value: 120,
  unit: 'mmHg',
  ucumCode: 'mm[Hg]',
  performerId: '67890'
});

console.log(`Observation created: ${systolicBP.id}`);

Codes LOINC Courants

Création d'une Condition (Entrée de la Liste de Problèmes)

Ajouter un diagnostic à la liste de problèmes :

const createCondition = async (conditionData) => {
  const condition = {
    resourceType: 'Condition',
    clinicalStatus: {
      coding: [{
        system: 'http://terminology.hl7.org/CodeSystem/condition-clinical',
        code: conditionData.status || 'active'
      }]
    },
    verificationStatus: {
      coding: [{
        system: 'http://terminology.hl7.org/CodeSystem/condition-ver-status',
        code: 'confirmed'
      }]
    },
    category: [
      {
        coding: [{
          system: 'http://terminology.hl7.org/CodeSystem/condition-category',
          code: conditionData.category || 'problem-list-item'
        }]
      }
    ],
    code: {
      coding: [{
        system: 'http://snomed.info/sct',
        code: conditionData.sctCode,
        display: conditionData.display
      }]
    },
    subject: {
      reference: `Patient/${conditionData.patientId}`
    },
    onsetDateTime: conditionData.onsetDate,
    recordedDate: new Date().toISOString()
  };

  const response = await fhirRequest('/Condition', {
    method: 'POST',
    body: JSON.stringify(condition)
  });

  return response;
};

// Usage - Add diabetes to problem list
const diabetes = await createCondition({
  patientId: '12345',
  sctCode: '44054006',
  display: 'Type 2 Diabetes Mellitus',
  status: 'active',
  category: 'problem-list-item',
  onsetDate: '2024-01-15'
});

Codes SNOMED CT Courants

Récupération des Médicaments du Patient

Obtenir les demandes de médicaments actives :

const getPatientMedications = async (patientId) => {
  const response = await fhirRequest(
    `/MedicationRequest?patient=${patientId}&status=active`
  );

  return response;
};

// Usage
const medications = await getPatientMedications('12345');

medications.entry?.forEach(entry => {
  const med = entry.resource;
  console.log(`${med.medicationCodeableConcept.coding[0].display}`);
  console.log(`  Dose: ${med.dosageInstruction[0]?.text}`);
  console.log(`  Status: ${med.status}`);
});

Récupération des Résultats de Laboratoire

Obtenir les rapports de diagnostic et les observations :

const getPatientLabResults = async (patientId, options = {}) => {
  const params = new URLSearchParams({
    patient: patientId,
    category: options.category || 'laboratory'
  });

  if (options.dateFrom) {
    params.append('date', `ge${options.dateFrom}`);
  }

  const response = await fhirRequest(`/DiagnosticReport?${params.toString()}`);
  return response;
};

// Get specific lab test (e.g., HbA1c)
const getLabValue = async (patientId, loincCode) => {
  const params = new URLSearchParams({
    patient: patientId,
    code: loincCode
  });

  const response = await fhirRequest(`/Observation?${params.toString()}`);
  return response;
};

// Usage - Get HbA1c results
const hba1c = await getLabValue('12345', '4548-4');
hba1c.entry?.forEach(entry => {
  const obs = entry.resource;
  console.log(`HbA1c: ${obs.valueQuantity.value} ${obs.valueQuantity.unit}`);
  console.log(`Date: ${obs.effectiveDateTime}`);
});

OAuth 2.0 et SMART on FHIR

Comprendre l'Authentification FHIR

Les serveurs FHIR utilisent OAuth 2.0 avec OpenID Connect :

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Client    │───▶│   Serveur   │───▶│   Serveur   │
│   (App)     │    │   d'Auth    │    │   FHIR      │
└─────────────┘    └─────────────┘    └─────────────┘
     │                    │                    │
     │  1. Demande d'Auth │                    │
     │───────────────────▶│                    │
     │                    │                    │
     │  2. Connexion      │                    │
     │     Utilisateur    │                    │
     │◀───────────────────│                    │
     │                    │                    │
     │  3. Code d'Auth    │                    │
     │───────────────────▶│                    │
     │                    │                    │
     │  4. Demande de     │                    │
     │     Token          │                    │
     │───────────────────▶│                    │
     │                    │  5. Token + ID     │
     │◀───────────────────│                    │
     │                    │                    │
     │  6. Requête API    │                    │
     │────────────────────────────────────────▶│
     │                    │                    │
     │  7. Données FHIR   │                    │
     │◀────────────────────────────────────────│

Lancement d'Application SMART on FHIR

Mettre en œuvre le lancement d'application SMART :

const crypto = require('crypto');

class SMARTClient {
  constructor(config) {
    this.clientId = config.clientId;
    this.redirectUri = config.redirectUri;
    this.issuer = config.issuer; // FHIR server URL
    this.scopes = config.scopes;
  }

  generatePKCE() {
    const codeVerifier = crypto.randomBytes(32).toString('base64url');
    const codeChallenge = crypto
      .createHash('sha256')
      .update(codeVerifier)
      .digest('base64url');

    return { codeVerifier, codeChallenge };
  }

  buildAuthUrl(state, patientId = null) {
    const { codeVerifier, codeChallenge } = this.generatePKCE();

    // Store codeVerifier for token exchange
    this.codeVerifier = codeVerifier;

    const params = new URLSearchParams({
      response_type: 'code',
      client_id: this.clientId,
      redirect_uri: this.redirectUri,
      scope: this.scopes.join(' '),
      state: state,
      code_challenge: codeChallenge,
      code_challenge_method: 'S256',
      aud: this.issuer,
      launch: patientId ? `patient-${patientId}` : null
    });

    return `${this.issuer}/authorize?${params.toString()}`;
  }

  async exchangeCodeForToken(code) {
    const response = await fetch(`${this.issuer}/token`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/x-www-form-urlencoded'
      },
      body: new URLSearchParams({
        grant_type: 'authorization_code',
        code: code,
        redirect_uri: this.redirectUri,
        client_id: this.clientId,
        code_verifier: this.codeVerifier
      })
    });

    const data = await response.json();

    return {
      accessToken: data.access_token,
      refreshToken: data.refresh_token,
      expiresIn: data.expires_in,
      patientId: data.patient,
      encounterId: data.encounter
    };
  }
}

// Usage
const smartClient = new SMARTClient({
  clientId: 'my-app-client-id',
  redirectUri: 'https://myapp.com/callback',
  issuer: 'https://fhir.epic.com',
  scopes: [
    'openid',
    'profile',
    'patient/Patient.read',
    'patient/Observation.read',
    'patient/Condition.read',
    'patient/MedicationRequest.read',
    'offline_access'
  ]
});

// Redirect user to auth URL
const state = crypto.randomBytes(16).toString('hex');
const authUrl = smartClient.buildAuthUrl(state);
console.log(`Redirect to: ${authUrl}`);

Scopes SMART Requises

Effectuer des Requêtes FHIR Authentifiées

class FHIRClient {
  constructor(accessToken, fhirBaseUrl) {
    this.accessToken = accessToken;
    this.baseUrl = fhirBaseUrl;
  }

  async request(endpoint, options = {}) {
    const response = await fetch(`${this.baseUrl}/fhir${endpoint}`, {
      ...options,
      headers: {
        'Accept': 'application/fhir+json',
        'Authorization': `Bearer ${this.accessToken}`,
        ...options.headers
      }
    });

    if (!response.ok) {
      const error = await response.json();
      throw new Error(`FHIR Error: ${error.issue?.[0]?.details?.text}`);
    }

    return response.json();
  }

  async getPatient(patientId) {
    return this.request(`/Patient/${patientId}`);
  }

  async searchPatients(params) {
    const query = new URLSearchParams(params);
    return this.request(`/Patient?${query.toString()}`);
  }
}

// Usage after OAuth callback
const fhirClient = new FHIRClient(tokens.accessToken, 'https://fhir.epic.com');
const patient = await fhirClient.getPatient(tokens.patientId);

Opérations par Lots et par Transactions

Requêtes par Lots

Exécuter plusieurs requêtes indépendantes :

const batchRequest = async (requests) => {
  const bundle = {
    resourceType: 'Bundle',
    type: 'batch',
    entry: requests.map(req => ({
      resource: req.resource,
      request: {
        method: req.method,
        url: req.url
      }
    }))
  };

  const response = await fhirRequest('', {
    method: 'POST',
    body: JSON.stringify(bundle)
  });

  return response;
};

// Usage - Fetch multiple resources
const bundle = await batchRequest([
  { method: 'GET', url: 'Patient/12345' },
  { method: 'GET', url: 'Patient/12345/Observation?category=vital-signs' },
  { method: 'GET', url: 'Patient/12345/Condition?clinical-status=active' }
]);

bundle.entry.forEach((entry, index) => {
  console.log(`Response ${index}: ${entry.response.status}`);
  console.log(entry.resource);
});

Requêtes de Transaction

Exécuter plusieurs requêtes comme une unité atomique :

const transactionRequest = async (requests) => {
  const bundle = {
    resourceType: 'Bundle',
    type: 'transaction',
    entry: requests.map(req => ({
      resource: req.resource,
      request: {
        method: req.method,
        url: req.url
      }
    }))
  };

  const response = await fhirRequest('', {
    method: 'POST',
    body: JSON.stringify(bundle)
  });

  return response;
};

// Usage - Create patient and related resources
const transaction = await transactionRequest([
  {
    method: 'POST',
    url: 'Patient',
    resource: {
      resourceType: 'Patient',
      name: [{ family: 'Doe', given: ['Jane'] }],
      gender: 'female',
      birthDate: '1990-01-01'
    }
  },
  {
    method: 'POST',
    url: 'Condition',
    resource: {
      resourceType: 'Condition',
      clinicalStatus: { coding: [{ code: 'active' }] },
      code: { coding: [{ system: 'http://snomed.info/sct', code: '38341003' }] },
      subject: { reference: 'Patient/-1' } // Reference to first resource
    }
  }
]);

Abonnements et Webhooks

Abonnements FHIR (R4B+)

S'abonner aux changements de ressources :

const createSubscription = async (subscriptionData) => {
  const subscription = {
    resourceType: 'Subscription',
    status: 'requested',
    criteria: subscriptionData.criteria,
    reason: subscriptionData.reason,
    channel: {
      type: 'rest-hook',
      endpoint: subscriptionData.endpoint,
      payload: 'application/fhir+json'
    }
  };

  const response = await fhirRequest('/Subscription', {
    method: 'POST',
    body: JSON.stringify(subscription)
  });

  return response;
};

// Usage - Subscribe to new lab results
const subscription = await createSubscription({
  criteria: 'DiagnosticReport?category=laboratory&patient=12345',
  reason: 'Monitor patient lab results',
  endpoint: 'https://myapp.com/webhooks/fhir'
});

Gérer les Webhooks FHIR

const express = require('express');
const app = express();

app.post('/webhooks/fhir', express.json({ type: 'application/fhir+json' }), async (req, res) => {
  const notification = req.body;

  // Verify subscription reference
  if (notification.subscription !== expectedSubscription) {
    return res.status(401).send('Unauthorized');
  }

  // Process notification
  if (notification.event?.resourceType === 'DiagnosticReport') {
    const reportId = notification.event.resourceId;
    const report = await fhirRequest(`/DiagnosticReport/${reportId}`);

    // Process new lab result
    await processLabResult(report);
  }

  res.status(200).send('OK');
});

Dépannage des Problèmes Courants

Problème : 401 Non autorisé

Symptômes : Obtention d'erreurs "Non autorisé" ou "Jeton invalide".

Solutions :

1. Vérifiez que le jeton n'a pas expiré
2. Vérifiez que le scope du jeton inclut la ressource demandée
3. Assurez-vous que l'en-tête Authorization: Bearer {token} est présent
4. Vérifiez que l'URL du serveur FHIR correspond à l'audience du jeton

Problème : 403 Interdit

Symptômes : Le jeton est valide mais l'accès est refusé.

Solutions :

1. Vérifiez que l'utilisateur a la permission pour la ressource demandée
2. Vérifiez que le contexte du patient correspond (pour les jetons à scope patient)
3. Assurez-vous que les scopes SMART incluent l'opération demandée
4. Vérifiez les contrôles d'accès au niveau des ressources

Problème : 404 Introuvable

Symptômes : La ressource n'existe pas ou le point de terminaison est incorrect.

Solutions :

1. Vérifiez que l'ID de la ressource est correct
2. Vérifiez que l'URL de base FHIR est correcte
3. Assurez-vous que le type de ressource est pris en charge par le serveur
4. Vérifiez le point de terminaison spécifique à la version (R4 vs R4B)

Problème : 422 Entité non traitable

Symptômes : Erreurs de validation lors de la création/mise à jour.

Solutions :

// Parse validation errors
const error = await response.json();
error.issue?.forEach(issue => {
  console.log(`Gravité: ${issue.severity}`);
  console.log(`Emplacement: ${issue.expression?.join('.')}`);
  console.log(`Message: ${issue.details?.text}`);
});

Causes courantes :

• Champs obligatoires manquants
• Valeurs de système de code invalides
• Format de référence incorrect
• Problèmes de format de date

Liste de Contrôle pour le Déploiement en Production

Avant la mise en ligne :

• [ ] Configurez OAuth 2.0 avec SMART on FHIR
• [ ] Implémentez la logique de rafraîchissement des jetons
• [ ] Mettez en place une gestion des erreurs appropriée
• [ ] Ajoutez une journalisation complète (pas d'informations de santé protégées dans les journaux)
• [ ] Implémentez la limitation de débit
• [ ] Configurez la logique de réessai avec un backoff exponentiel
• [ ] Testez avec plusieurs fournisseurs de DSE
• [ ] Validez avec le validateur FHIR
• [ ] Documentez toutes les opérations FHIR
• [ ] Mettez en place la surveillance et les alertes
• [ ] Créez un guide d'exploitation pour les problèmes courants

Validation FHIR

const { FhirValidator } = require('fhir-validator');

const validator = new FhirValidator('4.0.1');

const validateResource = async (resource) => {
  const validationResult = await validator.validate(resource);

  if (!validationResult.valid) {
    validationResult.issues.forEach(issue => {
      console.error(`Erreur de validation : ${issue.message}`);
      console.error(`Emplacement : ${issue.path}`);
    });
    throw new Error('La validation de la ressource a échoué');
  }

  return true;
};

// Usage before create/update
await validateResource(patientResource);

Cas d'Utilisation Réels

Intégration de Portail Patient

Un système de santé construit un portail patient :

• Défi: Les patients ne pouvaient pas accéder à leurs dossiers provenant de plusieurs prestataires
• Solution: Application SMART on FHIR avec intégration Epic et Cerner
• Résultat: 80 % d'adoption par les patients, 50 % de réduction des demandes de dossiers

Implémentation clé :

• Lancement d'application SMART orientée patient
• Accès en lecture seule aux ressources Patient, Observation, Condition, MedicationRequest
• Rafraîchissement du jeton pour des sessions persistantes
• Interface utilisateur réactive sur mobile

Aide à la Décision Clinique

Une plateforme de gestion des soins ajoute le CDS :

• Défi: Les prestataires manquent des opportunités de soins préventifs
• Solution: Requêtes FHIR en temps réel pour les lacunes de soins
• Résultat: Amélioration de 25 % des scores HEDIS

Implémentation clé :

• Application SMART orientée prestataire
• Interroger Patient, Condition, Observation, Immunisation
• Calculer les lacunes de soins basées sur les directives
• Recommandations intégrées au flux de travail du DSE

Analyse de la Santé de la Population

Un payeur construit un tableau de bord de santé de la population :

• Défi: Données incomplètes dans les réseaux de prestataires
• Solution: Exportation de données massives FHIR pour l'analyse
• Résultat: Vue à 360 degrés du patient, réduction des coûts PMPM

Implémentation clé :

• Accès aux données massives FHIR ($export)
• Exportations nocturnes vers l'entrepôt de données
• Modèles de stratification des risques
• Alertes du gestionnaire de soins

Conclusion

HL7 FHIR constitue la base de l'interopérabilité moderne des soins de santé. Principaux points à retenir :

• FHIR R4 est la norme actuelle pour l'intégration des API de santé
• SMART on FHIR permet une authentification sécurisée OAuth 2.0
• Les types de ressources standardisent les données sur les patients, les observations, les conditions et les médicaments
• Les paramètres de recherche permettent des requêtes flexibles
• Les opérations par lots et par transactions prennent en charge les workflows complexes
• Apidog simplifie les tests et la documentation des API FHIR

Section FAQ

À quoi sert HL7 FHIR ?

FHIR permet l'échange standardisé de données de santé entre les DSE, les portails patients, les applications mobiles et d'autres systèmes informatiques de santé. Les cas d'utilisation courants incluent les applications d'accès patient, l'aide à la décision clinique, la santé de la population et la coordination des soins.

Comment démarrer avec FHIR ?

Commencez par accéder à un serveur FHIR public (comme le serveur de test HAPI FHIR) ou configurez un service FHIR cloud (API Azure pour FHIR, AWS HealthLake). Entraînez-vous à lire des ressources et à utiliser les paramètres de recherche.

Quelle est la différence entre HL7 v2 et FHIR ?

HL7 v2 utilise des messages délimités par des pipes (ADT, ORM, ORU) pour l'échange de données basé sur les événements. FHIR utilise des API RESTful avec JSON/XML pour l'accès basé sur les ressources. FHIR est plus facile à implémenter et mieux adapté aux applications web/mobiles modernes.

FHIR est-il conforme HIPAA ?

FHIR est une norme de format de données en soi. La conformité HIPAA dépend de l'implémentation : chiffrement, authentification, contrôles d'accès et journalisation des audits. Utilisez OAuth 2.0 avec SMART on FHIR pour un accès sécurisé.

Que sont les scopes SMART ?

Les scopes SMART définissent des autorisations d'accès granulaires pour les ressources FHIR (par exemple, patient/Observation.read, user/*.read). Ne demandez que les scopes dont votre application a besoin.

Comment rechercher des ressources dans FHIR ?

Utilisez les requêtes GET avec des paramètres de requête : /Patient?name=Smith&birthdate=ge1980-01-01. FHIR prend en charge les modificateurs (:exact, :contains) et les préfixes (gt, lt, ge, le).

Qu'est-ce que Bulk FHIR ?

Bulk FHIR ($export) permet l'exportation asynchrone de grands ensembles de données au format NDJSON. Utilisé pour la santé de la population, l'analyse et l'entreposage de données.

Comment gérer le versioning de FHIR ?

Ciblez une version FHIR spécifique (R4 recommandé) et utilisez des points de terminaison spécifiques à la version. Vérifiez le CapabilityStatement pour les versions et les ressources prises en charge.

Puis-je étendre FHIR avec des champs personnalisés ?

Oui, utilisez les extensions FHIR pour ajouter des éléments de données personnalisés. Définissez les extensions dans votre Guide d'implémentation et enregistrez-les auprès de HL7 si vous les partagez largement.

Quels outils facilitent le développement FHIR ?

Les outils populaires incluent HAPI FHIR (serveur open source), le validateur FHIR, les collections Postman et Apidog pour les tests et la documentation d'API.