Lab PDF Extraction

x-api-key: your-api-key-here

async function uploadLabPDF(filePath) {
  const pdfBase64 = fs.readFileSync(filePath).toString('base64');



  const response = await fetch(
    'https://api.voloridgehealth.com/extraction/lab/upload',
    {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'x-api-key': 'YOUR_API_KEY'
      },
      body: JSON.stringify({
        pdfFile: pdfBase64,
        filename: 'lab_results_2024.pdf',
        dateOfBirth: '1985-03-15',
        webhookUrl: 'https://yourapp.com/api/webhooks/lab-results'
      })
    }
  );



  const { jobId, status } = await response.json();
  console.log(`Job created: ${jobId} — status: ${status}`);
  return jobId;
}

import base64, requests

def upload_lab_pdf(file_path):
    with open(file_path, 'rb') as f:
        pdf_base64 = base64.b64encode(f.read()).decode('utf-8')

    response = requests.post(
        'https://api.voloridgehealth.com/extraction/lab/upload',
        headers={
            'Content-Type': 'application/json',
            'x-api-key': 'YOUR_API_KEY'
        },
        json={
            'pdfFile': pdf_base64,
            'filename': 'lab_results_2024.pdf',
            'dateOfBirth': '1985-03-15',
            'webhookUrl': 'https://yourapp.com/api/webhooks/lab-results'
        }
    )
    data = response.json()
    print(f"Job created: {data['jobId']} — status: {data['status']}")
    return data['jobId']

{
  "jobId": "550e8400-e29b-41d4-a716-446655440000_1699564800",
  "status": "queued",
  "message": "PDF uploaded successfully. Processing started."
}

async function uploadLargePDF(filePath) {
  // Step 1: Request a presigned URL (omit pdfFile)
  const initRes = await fetch(
    'https://api.voloridgehealth.com/extraction/lab/upload',
    {
      method: 'POST',
      headers: { 'Content-Type': 'application/json', 'x-api-key': 'YOUR_API_KEY' },
      body: JSON.stringify({
        filename: 'large_lab_report.pdf',
        dateOfBirth: '1985-03-15',
        webhookUrl: 'https://yourapp.com/api/webhooks/lab-results'
      })
    }
  );
  const { jobId, uploadUrl } = await initRes.json();

  // Step 2: PUT the PDF directly to S3
  const fs = require('fs');
  await fetch(uploadUrl, {
    method: 'PUT',
    headers: { 'Content-Type': 'application/pdf' },
    body: fs.readFileSync(filePath)
  });

  console.log('Upload complete. Processing will start automatically.');
  return jobId;
}

import requests

def upload_large_pdf(file_path):
    # Step 1: Request a presigned URL (no pdfFile)
    data = requests.post(
        'https://api.voloridgehealth.com/extraction/lab/upload',
        headers={'Content-Type': 'application/json', 'x-api-key': 'YOUR_API_KEY'},
        json={
            'filename': 'large_lab_report.pdf',
            'dateOfBirth': '1985-03-15',
            'webhookUrl': 'https://yourapp.com/api/webhooks/lab-results'
        }
    ).json()

    # Step 2: PUT the PDF directly to S3
    with open(file_path, 'rb') as f:
        requests.put(data['uploadUrl'], data=f, headers={'Content-Type': 'application/pdf'})

    print('Upload complete. Processing starts automatically.')
    return data['jobId']

async function waitForResults(jobId, intervalMs = 15000) {
  const url = `https://api.voloridgehealth.com/extraction/lab/status/${jobId}`;
  const headers = { 'x-api-key': 'YOUR_API_KEY' };

  while (true) {
    const data = await fetch(url, { headers }).then(r => r.json());
    console.log(`Status: ${data.status}`);

    if (data.status === 'completed') {
      return data; // full results included in status response
    }
    if (['failed', 'quarantined', 'rejected_phi', 'invalid_document'].includes(data.status)) {
      throw new Error(`Job ended with status: ${data.status}`);
    }

    await new Promise(r => setTimeout(r, intervalMs));
  }
}

import time, requests

TERMINAL = {'completed', 'failed', 'quarantined', 'rejected_phi', 'invalid_document'}

def wait_for_results(job_id, interval=15):
    url = f'https://api.voloridgehealth.com/extraction/lab/status/{job_id}'
    headers = {'x-api-key': 'YOUR_API_KEY'}

    while True:
        data = requests.get(url, headers=headers).json()
        print(f"Status: {data['status']}")

        if data['status'] == 'completed':
            return data  # full results included
        if data['status'] in TERMINAL:
            raise Exception(f"Job ended: {data['status']}")

        time.sleep(interval)

const express = require('express');
const app = express();
app.use(express.json());

app.post('/api/webhooks/lab-results', (req, res) => {
  // 1. Authenticate
  if (req.headers['x-api-key'] !== process.env.VOLORIDGE_WEBHOOK_KEY) {
    return res.status(401).send('Unauthorized');
  }

  const { event, jobId, data } = req.body;

  if (event === 'job.completed') {
    const { labName, dateCollected, panels, verification } = data;

    panels.forEach(panel => {
      console.log(`Panel: ${panel.panelName}`);
      panel.panelResults.forEach(r => {
        console.log(`  ${r.biomarker}: ${r.resultValue} ${r.resultUnit}`
          + ` (LOINC: ${r.loincCode}, UCUM: ${r.ucumCode})`);
      });
    });

    if (verification?.dobMatches === false) {
      console.warn('DOB mismatch — flag for review');
    }

  } else if (event === 'job.failed') {
    console.error(`Job failed: ${data.error.message}`);

  } else if (event === 'job.invalid_document') {
    console.warn(`Invalid document: ${data.error.rejection_reason}`);
  }

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

from flask import Flask, request, jsonify
import os

app = Flask(__name__)

@app.route('/api/webhooks/lab-results', methods=['POST'])
def lab_webhook():
    # 1. Authenticate
    if request.headers.get('X-API-Key') != os.environ['VOLORIDGE_WEBHOOK_KEY']:
        return jsonify({'error': 'Unauthorized'}), 401

    body = request.json
    event, data = body['event'], body['data']

    if event == 'job.completed':
        for panel in data['panels']:
            print(f"Panel: {panel['panelName']}")
            for r in panel['panelResults']:
                print(f"  {r['biomarker']}: {r['resultValue']} "
                      f"{r['resultUnit']} (LOINC: {r['loincCode']})")

    elif event == 'job.invalid_document':
        print(f"Rejected: {data['error']['rejection_reason']}")

    return jsonify({'received': True}), 200

{
  "event": "job.completed",
  "jobId": "550e8400-e29b-41d4-a716-446655440000_1699564800",
  "timestamp": "2025-11-15T10:35:18.415821+00:00",
  "data": {
    "jobId": "550e8400-e29b-41d4-a716-446655440000_1699564800",
    "status": "completed",
    "labName": "Quest Diagnostics",
    "dateCollected": "2024-04-11",
    "verification": { "dobFound": true, "dobMatches": true },
    "panels": [
      {
        "panelName": "Complete Blood Count",
        "panelCode": "CBC",
        "dateCollected": "2024-04-11",
        "pageNumber": 1,
        "panelResults": [
          {
            "biomarker": "White Blood Cell Count",
            "resultValue": "4.9",
            "resultType": "numeric",
            "resultUnit": "Thousand/uL",
            "loincCode": "6690-2",
            "loincMatchType": "exact",
            "ucumCode": "10*3/uL",
            "ucumMatchMethod": "static_map",
            "minRefRangeValue": 3.8,
            "maxRefRangeValue": 10.8,
            "referenceRangeText": "3.8-10.8",
            "pageNumber": 1
          }
        ]
      }
    ]
  }
}

{
  "error": "invalid_pdf",
  "message": "PDF file is corrupted or unreadable",
  "timestamp": "2025-11-15T10:30:22Z",
  "requestId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
}