---
updatedAt: 2025-04-09T15:08:46.000Z
agentTools:
  projectIndex: https://docs.chartinsight.ai/llms.txt
---

# Adding Medical Records, Processing, and Retrieving AI Assets

```ruby Ruby
require 'uri'
require 'net/http'
require 'openssl'
require 'json'
require 'pp'

BASE_API_URL = "https://api.judyai.io/v1/"
API_KEY = "YOUR_API_KEY"

# ----------------------------------------------------------------------------------------
# HTTP Request Helper methods
# ----------------------------------------------------------------------------------------
def get_request(endpoint, params = {})
  url = URI("#{BASE_API_URL}#{endpoint}")
  url.query = URI.encode_www_form(params)

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  request = Net::HTTP::Get.new(url)
  request["accept"] = 'application/json'
  request["content-type"] = 'application/json'
  request["authorization"] = "Bearer #{API_KEY}"
  response = http.request(request)

  return JSON.parse(response.read_body)
end

def post_request(endpoint, request_object)
  url = URI("#{BASE_API_URL}#{endpoint}")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  request = Net::HTTP::Post.new(url)
  request["accept"] = 'application/json'
  request["content-type"] = 'application/json'
  request["authorization"] = "Bearer #{API_KEY}"
  request.body = request_object.to_json
  response = http.request(request)

  return JSON.parse(response.read_body)
end

# ----------------------------------------------------------------------------------------
# Add a new medical record to Judy AI
# ----------------------------------------------------------------------------------------
def add_medical_record_to_judy(request)
  add_medical_record_url = "medical_record/add"
  puts "ADDING MEDICAL RECORD TO JUDY..."
  medical_record = post_request(add_medical_record_url, request)
  puts "MEDICAL RECORD ADDED TO JUDY!"
  puts "--------------------------------------------"
  pp medical_record
  puts "--------------------------------------------"
  return medical_record
end

# ----------------------------------------------------------------------------------------
# Check the processing status of the medical record
# ----------------------------------------------------------------------------------------
def check_medical_record_processing_status(medical_record)
  start_time = Time.now
  wait_seconds = 60
  while !medical_record["processing_completed"] do
    puts "CHECKING MEDICAL RECORD PROCESSING STATUS (~5 min per 100 pages)..."
    get_medical_record_url = "medical_record/#{medical_record["id"]}"
    medical_record = get_request(get_medical_record_url)

    if medical_record["processing_error"]
      raise "ERROR PROCESSING MEDICAL RECORD - #{medical_record['processing_error_description']}"
    end

    if medical_record["processing_completed"]
      puts "MEDICAL RECORD PROCESSING COMPLETED IN #{((Time.now - start_time) / 60).round(2)} MINUTES"
    else
      puts "MEDICAL RECORD NOT COMPLETED YET (MINUTES ELASPED #{((Time.now - start_time) / 60).round(2)})"
      medical_record["processing_tasks"].each do |task|
        puts "#{task["task"]} completed: #{task["completed"]}"
      end
      puts "RECHECKING IN #{wait_seconds} SECONDS..."
      sleep wait_seconds
    end
    puts "--------------------------------------------"
  end
  return medical_record
end

# ----------------------------------------------------------------------------------------
# Get the medical record's AI assets
# ----------------------------------------------------------------------------------------
def get_assets(medical_record)
  puts "GETTING MEDICAL RECORD'S ASSETS..."
  get_medical_record_assets_url = "medical_record/#{medical_record["id"]}/assets"
  medical_record_assets = get_request(get_medical_record_assets_url)
  puts "ASSETS RETRIEVED!"
  puts ""

  puts "DETAILED INDEX:"
  medical_record_assets['detailed_index']['rows'].each do |row|
    puts ""
    puts "date: #{row["date"]}"
    puts "provider: #{row["provider"]}"
    puts "extract_title: #{row["extract_title"]}"
    puts "extract: #{row["extract"]}"
    puts "page_ranges:"
    row["page_ranges"].each do |page_range|
      puts "#{page_range["start"]} - #{page_range["end"]}"
    end
  end

  puts "--------------------------------------------"
  return medical_record_assets
end

# ----------------------------------------------------------------------------------------
# Get the medical record's secure rendered document URLs
# ----------------------------------------------------------------------------------------
def get_document_urls(medical_record)
  puts "GETTING MEDICAL RECORD'S DOCUMENT URLS..."
  get_medical_record_document_urls_url = "medical_record/#{medical_record["id"]}/document_urls"
  medical_record_document_urls = get_request(get_medical_record_document_urls_url)
  puts "DOCUMENT URLS RETRIEVED!"
  puts ""
  pp medical_record_document_urls

  puts "--------------------------------------------"
  return medical_record_document_urls
end

# ----------------------------------------------------------------------------------------
# Main
# ----------------------------------------------------------------------------------------
def main
  medical_record_to_add = {
    "name" => "A New Medical Record",
    "file_url" => "YOUR_MEDICAL_RECORD_URL", # be sure to use secure URLs with expiry
    "processing_tasks_configuration" => {
      "perform_ocr" => true,
	  "perform_phi_validation" => true,
	  "generate_detailed_index" => true,
	  "generate_summary_index" => false,
	  "generate_conditions_list" => false,
	  "generate_medications_list" => false,
	  "generate_pain_scale_timeline" => false,
	  "generate_bp_timeline" => false,
	  "generate_pdf" => true,
	  "generate_condensed_pdf" => false
    },
   	"validation_info" => {
      "first_name" => "John",
      "middle_name" => "Jacob",
      "last_name" => "Smith",
      "date_of_birth" => "01-01-1980",
      "ssn" => '111-11-1111'
    },
	"insert_before_page" => nil,
	"start_at_page" => nil,
	"end_at_page" => nil,
	"audience" => 'attorney'
  }

  medical_record = add_medical_record_to_judy(medical_record_to_add)

  # medical_record = {
  #     "id" => "4d11c5ad-b95b-4c71-8dc0-a4bf211550a3"
  # }

  medical_record = check_medical_record_processing_status(medical_record)
  medical_record_assets = get_assets(medical_record)
  medical_record_document_urls = get_document_urls(medical_record)
end

main

```

```javascript JavaScript
// npm install api --save
const sdk = require("api")("@judyai/v1.0#1lkadlplum0tzde");
sdk.auth("YOUR_API_KEY");

// ----------------------------------------------------------------------------------------
// Add a new medical record to Judy AI
// ----------------------------------------------------------------------------------------
const addMedicalRecord = async (medicalRecordToAdd) => {
  try {
    console.log("ADDING MEDICAL RECORD TO JUDY...");
    const response =
      await sdk.add_medical_record_v1_medical_record_add_post(
        medicalRecordToAdd,
      );

    console.log("MEDICAL RECORD ADDED TO JUDY!");
    console.log("--------------------------------------------");
    console.log(response.data);
    console.log("--------------------------------------------");

    return response.data;
  } catch (err) {
    console.error(err);
  }
};

// ----------------------------------------------------------------------------------------
// Check the processing status of the medical record
// ----------------------------------------------------------------------------------------
const checkProcessingStatus = async (medicalRecordId) => {
  let processingCompleted = false;
  const waitSeconds = 60;
  const startTime = Date.now();

  while (!processingCompleted) {
    console.log(
      "CHECKING MEDICAL RECORD PROCESSING STATUS (~5 min per 100 pages)...",
    );

    const response =
      await sdk.get_medical_record_v1_medical_record__medical_record_id__get({
        medical_record_id: medicalRecordId,
      });
    const medicalRecordData = response.data;

    if (medicalRecordData["processing_error"]) {
      throw new Error(
        `ERROR PROCESSING MEDICAL RECORD - ${medicalRecordData["processing_error_description"]}`,
      );
    }

    processingCompleted = medicalRecordData.processing_completed;

    if (processingCompleted) {
      console.log(
        `MEDICAL RECORD PROCESSING COMPLETED IN ${((Date.now() - startTime) / 60000).toFixed(2)} MINUTES`,
      );
    } else {
      console.log(
        `MEDICAL RECORD PROCESSING NOT COMPLETED YET (MINUTES ELASPED ${((Date.now() - startTime) / 60000).toFixed(2)})`,
      );
      medicalRecordData.processing_tasks.forEach((task) => {
        console.log(`${task.task} completed: ${task.completed}`);
      });
      console.log(`RECHECKING IN ${waitSeconds} SECONDS...`);
      await new Promise((resolve) => setTimeout(resolve, waitSeconds * 1000));
    }
    console.log("--------------------------------------------");
  }
};

// ----------------------------------------------------------------------------------------
// Get the medical record's assets
// ----------------------------------------------------------------------------------------
const getAssets = async (medicalRecordId) => {
  try {
    console.log("GETTING MEDICAL RECORD'S ASSETS...");
    const response =
      await sdk.get_medical_record_assets_v1_medical_record__medical_record_id__assets_get(
        { medical_record_id: medicalRecordId },
      );
    console.log("ASSETS RETRIEVED!");
    console.log("");

    const assetsData = response.data;

    console.log("DETAILED INDEX:");
    assetsData["detailed_index"]["rows"].forEach((row) => {
      console.log("--------------------------------------------");
      console.log(`date: ${row.date}`);
      console.log(`provider: ${row.provider}`);
      console.log(`extract_title: ${row.extract_title}`);
      console.log(`extract: ${row.extract}`);
      console.log(`page_ranges:`);
      row["page_ranges"].forEach((pageRange) => {
        console.log(`${pageRange.start} - ${pageRange.end}`);
      });
    });

    console.log("--------------------------------------------");
  } catch (err) {
    console.error(err);
  }
};

// ----------------------------------------------------------------------------------------
// Get the medical record's secure rendered document URLs
// ----------------------------------------------------------------------------------------
const getDocumentURLs = async (medicalRecordId) => {
  try {
    console.log("GETTING MEDICAL RECORD'S DOCUMENT URLS...");
    const response =
      await sdk.get_medical_record_document_urls_v1_medical_record__medical_record_id__document_urls_get(
        { medical_record_id: medicalRecordId },
      );
    console.log("DOCUMENT URLS RETRIEVED!");
    console.log("");

    const urlsData = response.data;

    console.log("DOCUMENT URLS:");
    console.log(urlsData);

    console.log("--------------------------------------------");
  } catch (err) {
    console.error(err);
  }
};

// ----------------------------------------------------------------------------------------
// Main
// ----------------------------------------------------------------------------------------
const main = async () => {
  // Be sure to use secure URLs with an expiry > 1 hour!
	// File URLs must be direct links to the file, not a download page (e.g. Dropbox, Google Drive, etc.)
  const medicalRecordToAdd = {
    name: "A New Medical Record",
    file_url: "YOUR_MEDICAL_RECORD_URL",
    processing_tasks_configuration: {
      perform_ocr: true,
      perform_phi_validation: false,
      generate_detailed_index: true,
      generate_summary_index: false,
      generate_conditions_list: false,
      generate_medications_list: false,
      generate_pain_scale_timeline: false,
      generate_bp_timeline: false,
      generate_pdf: true,
      generate_condensed_pdf: false,
    },
    validation_info: null,
    insert_before_page: null,
    start_at_page: null,
    end_at_page: null,
    audience: "attorney",
  };

  const medicalRecord = await addMedicalRecord(medicalRecordToAdd);

  /*
  medicalRecord = {
    id: "c0e4ec84-6c4c-4437-b3d0-57ddf4284e87",
  };
  */

  await checkProcessingStatus(medicalRecord.id);
  await getAssets(medicalRecord.id);
  await getDocumentURLs(medicalRecord.id);
};

main();

```

```python Python
import requests
import json
import time
import pprint

BASE_API_URL = "https://api.judyai.io/v1/"
API_KEY = "YOUR_API_KEY"

# ----------------------------------------------------------------------------------------
# HTTP Request Helper methods
# ----------------------------------------------------------------------------------------
def get_request(endpoint, params=None):
    if params is None:
        params = {}
    url = f"{BASE_API_URL}{endpoint}"
    headers = {
        'accept': 'application/json',
        'content-type': 'application/json',
        'authorization': f"Bearer {API_KEY}"
    }
    response = requests.get(url, headers=headers, params=params)
    return response.json()


def post_request(endpoint, request_object):
    url = f"{BASE_API_URL}{endpoint}"
    headers = {
        'accept': 'application/json',
        'content-type': 'application/json',
        'authorization': f"Bearer {API_KEY}"
    }
    response = requests.post(url, headers=headers, json=request_object)
    return response.json()

# ----------------------------------------------------------------------------------------
# Add a new medical record to Judy AI
# ----------------------------------------------------------------------------------------
def add_medical_record_to_judy(request):
    add_medical_record_url = "medical_record/add"
    print("ADDING MEDICAL RECORD TO JUDY...")
    medical_record = post_request(add_medical_record_url, request)
    print("MEDICAL RECORD ADDED TO JUDY!")
    print("--------------------------------------------")
    pprint.pprint(medical_record)
    print("--------------------------------------------")
    return medical_record

# ----------------------------------------------------------------------------------------
# Check the processing status of the medical record
# ----------------------------------------------------------------------------------------
def check_medical_record_processing_status(medical_record):
    start_time = time.time()
    wait_seconds = 60
    while not medical_record["processing_completed"]:
        print("CHECKING MEDIA PROCESSING STATUS...")
        get_medical_record_url = f"medical_record/{medical_record['id']}"
        medical_record = get_request(get_medical_record_url)

        if medical_record["processing_error"]:
            raise Exception(f"ERROR PROCESSING MEDICAL RECORD - {medical_record['processing_error_description']}")

        if medical_record["processing_completed"]:
            print(f"MEDICAL RECORD PROCESSING COMPLETED IN {round((time.time() - start_time) / 60, 2)} MINUTES")
        else:
            print(f"MEDICAL RECORD PROCESSING NOT COMPLETED YET (MINUTES ELASPED {round((time.time() - start_time) / 60, 2)})")
            for task in medical_record["processing_tasks"]:
                print(f"{task['task']} completed: {task['completed']}")
            print(f"RECHECKING IN {wait_seconds} SECONDS...")
            time.sleep(wait_seconds)
        print("--------------------------------------------")
    return medical_record

# ----------------------------------------------------------------------------------------
# Get the medical record's AI assets
# ----------------------------------------------------------------------------------------
def get_assets(medical_record):
    print("GETTING MEDICAL RECORD'S ASSETS...")
    get_medical_record_assets_url = f"medical_record/{medical_record['id']}/assets"
    medical_record_assets = get_request(get_medical_record_assets_url)
    print("ASSETS RETRIEVED!")
    print("")

    print("DETAILED INDEX:")
    for row in medical_record_assets['detailed_index']['rows']:
        print("")
        print(f"date: {row['date']}")
        print(f"provider: {row['provider']}")
        print(f"extract_title: {row['extract_title']}")
        print(f"extract: {row['extract']}")
        print(f"page_ranges:")
        for page_range in row["page_ranges"]:
            print(f"{page_range['start']} - {page_range['end']}")

    print("--------------------------------------------")
    return medical_record_assets

# ----------------------------------------------------------------------------------------
# Get the medical record's secure rendered document URLs
# ----------------------------------------------------------------------------------------
def get_document_urls(medical_record):
    print("GETTING MEDICAL RECORD'S DOCUMENT URLS...")
    get_medical_record_document_urls_url = f"medical_record/{medical_record['id']}/document_urls"
    medical_record_document_urls = get_request(get_medical_record_document_urls_url)
    print("DOCUMENT URLS RETRIEVED!")
    print("")
    pprint.pprint(medical_record_document_urls)

    print("--------------------------------------------")
    return medical_record_document_urls

# ----------------------------------------------------------------------------------------
# Main
# ----------------------------------------------------------------------------------------
def main():
    medical_record_to_add = {
        "name": "A New Medical Record",
        "file_url":
          "YOUR_MEDICAL_RECORD_URL", # be sure to use secure URLs with expiry
        "processing_tasks_configuration": {
            "perform_ocr": True,
          "perform_phi_validation": True,
          "generate_detailed_index": True,
          "generate_summary_index": False,
          "generate_conditions_list": False,
          "generate_medications_list": False,
          "generate_pain_scale_timeline": False,
          "generate_bp_timeline": False,
          "generate_pdf": True,
          "generate_condensed_pdf": False
        },
        "validation_info": {
          "first_name": "John",
          "middle_name": "Jacob",
          "last_name": "Smith",
          "date_of_birth": "01-01-1980",
          "ssn": "111-11-1111",
        },
        "insert_before_page": None,
        "start_at_page": None,
        "end_at_page": None,
        "audience": "attorney"
      }

    medical_record = add_medical_record_to_judy(medical_record_to_add)

    # medical_record = {
    #   "id" => "2c9b2410-cf81-4487-be1e-7b4289520bcf"
    # }
    #
    medical_record = check_medical_record_processing_status(medical_record)
    medical_record_assets = get_assets(medical_record)
    medical_record_document_urls = get_document_urls(medical_record)

main()

```

```json Response Example
{"success":true}
```

# API setup

<!-- ruby@1-41 -->
<!-- javascript@1-3 -->
<!-- python@1-33 -->

First, let's knock out some API setup, insert our API key, and work up any needed helper methods (depending on language).

# Add medical record

<!-- ruby@43-55 -->
<!-- javascript@8-25 -->
<!-- python@35-46 -->

With setup out of the way, let's create a function to add a new medical to our Judy AI account.

# Check the medical record's processing status

<!-- ruby@57-85 -->
<!-- javascript@30-70 -->
<!-- python@48-71 -->

Next, we'll create a function to poll for the status of the medical record until processing is complete.

# Get the medical record's AI assets

<!-- ruby@87-112 -->
<!-- javascript@72-104 -->
<!-- python@73-95 -->

Now for the magic - let's create a function to retrieve all of the medical record's AI assets (such as the detailed index data) generated by Judy AI.

# Get the medical record generated document URLs

<!-- ruby@114-127 -->
<!-- javascript@106-128 -->
<!-- python@97-110 -->

Judy AI generates a PDF containing all of the AI generated assets for you. Easy!

# Putting it all together

<!-- ruby@129-173 -->
<!-- javascript@130-174 -->
<!-- python@111-154 -->

Finally, let's create a main function to put all of our steps together. LET'S GO! 🚀