Sundhed Dk

Sundhed.dk Health Data

This skill fetches personal health data from sundhed.dk by opening a browser, letting the user log in with MitID, then intercepting the JSON API responses and parsing them into readable text.

Quick Reference

Before fetching: check for existing data

Before opening a browser, check if data already exists:

node -e "
const fs = require('fs');
const db = 'data/sundhed-dk/health.db';
const parsed = 'data/sundhed-dk/parsed';
console.log('Database exists:', fs.existsSync(db));
console.log('Parsed dir exists:', fs.existsSync(parsed));
if (fs.existsSync(parsed)) {
  const files = fs.readdirSync(parsed).filter(f => f.endsWith('.md'));
  console.log('Parsed files:', files.join(', '));
}
"

If data exists, skip straight to querying or reading:

• For broad questions → read the relevant data/sundhed-dk/parsed/<section>.md file
• For specific/time-based questions → query data/sundhed-dk/health.db (see "Querying the database" below)
• Only re-fetch from sundhed.dk if the user asks for a refresh or the data is stale

Querying the database

When data/sundhed-dk/health.db exists, use SQL to answer targeted questions. The database uses Node.js built-in SQLite (node:sqlite).

node -e "
const { DatabaseSync } = require('node:sqlite');
const db = new DatabaseSync('data/sundhed-dk/health.db');
const rows = db.prepare('<SQL_QUERY>').all();
rows.forEach(r => console.log(JSON.stringify(r)));
db.close();
"

Common query patterns

Trend a lab value over time:

SELECT result_date, value, reference_text, assessment
FROM lab_results_biochemistry
WHERE analyse_name LIKE '%Urat%'
ORDER BY result_date

Find all elevated lab results:

SELECT analyse_name, result_date, value, reference_text
FROM lab_results_biochemistry
WHERE assessment = 'Forhoejet'
ORDER BY result_date DESC

List active medications with duration:

SELECT drug_name, indication, start_date,
  CAST((julianday('now') - julianday(start_date)) / 365.25 AS INT) AS years_on
FROM medications
WHERE status = 'Active'
ORDER BY start_date

Search microbiology results:

SELECT result_date, test_name, material, conclusion, finding_name, finding_interpretation
FROM lab_results_microbiology
WHERE test_name LIKE '%Chlamydia%'
ORDER BY result_date DESC

Upcoming appointments:

SELECT title, start_time, organisation, address, phone
FROM appointments
WHERE start_time > datetime('now')
ORDER BY start_time

Hospital history for a diagnosis:

SELECT diagnosis_name, diagnosis_code, hospital, department, date_from, date_to
FROM hospital_episodes
WHERE diagnosis_name LIKE '%eksem%'
ORDER BY date_from DESC

Database schema reference

Note: Biochemistry analyse_name uses full IUPAC names (e.g. P—C-reaktivt protein; massek. = ? mg/L). Use LIKE '%keyword%' for searching (e.g. LIKE '%Urat%', LIKE '%Cholesterol%', LIKE '%Cobalamin%').

Fetching fresh data from sundhed.dk

Only follow the steps below if data doesn't exist yet or the user wants to refresh it.

Step 1: Open browser and log in

The browser MUST be headed (so the user can interact with MitID) and persistent (to keep the session).

playwright-cli open https://sundhed.dk --browser=chrome --headed --persistent

Then navigate the login flow:

1. Dismiss cookies - Take a snapshot, find "Nej tak" button, click it
2. Click "Log på" - Top-right corner
3. Choose "Borger" - In the login dialog
4. MitID authentication - Tell the user to complete MitID login in the browser. Wait for them to confirm.
5. Verify login - After login, the browser should be at https://www.sundhed.dk/borger/min-side/

playwright-cli snapshot
playwright-cli click <ref-for-nej-tak>
playwright-cli snapshot
playwright-cli click <ref-for-log-paa>
playwright-cli snapshot
playwright-cli click <ref-for-borger>
# Ask user to complete MitID login

Step 2: Fetch the requested data

Navigate to the relevant page and intercept the JSON API responses. The data gets saved to data/sundhed-dk/ via a browser download trick (since require('fs') is not available in the run-code context).

First ensure the data directory exists:

mkdir -p data/sundhed-dk

Use this pattern to intercept and save JSON for any section:

playwright-cli run-code "async page => {
  const responses = [];
  const handler = async response => {
    const rUrl = response.url();
    if (rUrl.includes('/api/') && rUrl.includes('<API_KEYWORD>') && response.headers()['content-type']?.includes('json')) {
      try {
        const body = await response.json();
        responses.push({ url: rUrl, status: response.status(), body });
      } catch(e) {}
    }
  };
  page.on('response', handler);
  await page.goto('<PAGE_URL>');
  await page.waitForTimeout(6000);
  page.removeListener('response', handler);
  const json = JSON.stringify(responses, null, 2);
  await page.evaluate((opts) => {
    const blob = new Blob([opts.data], {type: 'application/json'});
    const u = URL.createObjectURL(blob);
    const a = document.createElement('a');
    a.href = u; a.download = opts.fn;
    document.body.appendChild(a); a.click();
    document.body.removeChild(a); URL.revokeObjectURL(u);
  }, { data: json, fn: '<FILENAME>.json' });
  await page.waitForTimeout(1000);
  return { count: responses.length };
}"

Then move the downloaded file to the data directory:

cp .playwright-cli/<FILENAME>.json data/sundhed-dk/<FILENAME>.json

Section-specific parameters

Step 3: Parse and save the data

Each section has a parser script that converts raw JSON into clean, LLM-friendly markdown. The parsers are bundled with this skill.

First ensure the parsed output directory exists:

mkdir -p data/sundhed-dk/parsed

Parse the JSON and save the markdown output:

node .claude/skills/sundhed-dk/parsers/parse-<section>.js < data/sundhed-dk/<section>.json > data/sundhed-dk/parsed/<section>.md

Available parsers:

Read the parsed markdown from data/sundhed-dk/parsed/<section>.md and present it to the user in a clear, helpful way.

Step 4: Build the SQLite database

After fetching JSON data, build a queryable SQLite database from all available sections:

node .claude/skills/sundhed-dk/parsers/build-db.js

This creates data/sundhed-dk/health.db with tables for all health data. The database is rebuilt fresh each time (idempotent). Use this for targeted queries across time, e.g.:

node -e "
const { DatabaseSync } = require('node:sqlite');
const db = new DatabaseSync('data/sundhed-dk/health.db');
const rows = db.prepare(\"SELECT result_date, value, assessment FROM lab_results_biochemistry WHERE analyse_name LIKE '%Urat%' ORDER BY result_date\").all();
rows.forEach(r => console.log(r.result_date?.split('T')[0], r.value, r.assessment));
db.close();
"

Database tables

When to use markdown vs SQLite:

• Markdown (parsed/*.md): Dump into LLM context for broad questions ("summarize my health", "what medications am I on")
• SQLite (health.db): Targeted queries across time ("trend my CRP", "which medications have I taken longest", "show all elevated lab results")

Important Notes

• Data storage: Raw JSON goes to data/sundhed-dk/, parsed markdown to data/sundhed-dk/parsed/, SQLite database to data/sundhed-dk/health.db. All are gitignored - personal health data never gets committed.
• Browser downloads land in .playwright-cli/ and must be copied to data/sundhed-dk/.
• Prøvesvar defaults to 6 months back. To see older results, change the date filter on the page before intercepting.
• Journaler has full history from 1999 onwards.
• Person selector on most pages lets the user switch between self and family members (children under 15).
• page.evaluate() only accepts a single argument - always wrap in { data, fn }.
• Element refs from snapshots are session-specific. Always take a fresh snapshot before clicking.
• Session persistence: Once logged in, the session stays active. No need to re-authenticate for subsequent navigations within the same browser session.

Detailed API Reference

For complete endpoint documentation, JSON structures, filter options, and sorting parameters, see navigation.md.

Converted and distributed by TomeVault — claim your Tome and manage your conversions.