Averbis Medical Language API

Download OpenAPI specification:Download

Introduction

The Averbis Medical Language API provides programmatic access to Averbis AI-based text analysis capabilities, making it possible to include high quality medical fact extraction directly into your applications. The API uses natural language processing (NLP) to detect entities, which are text references to medical information such as clinical facts, drugs and diagnostic observations from medical text documents. API features include data normalization and linking to standardized terminologies and classification systems such as ICD-10, SNOMED-CT or LOINC.

Clinical Facts

Diseases, signs, symptoms, treatments, DRG related codes, time course, confirmation status, family background etc.

Drugs

Strength, ingredients, dose form, dosage, frequency, time course, medical status, treatment, medication allergy, therapeutic chemical codes etc.

Diagnostic Observations

Laboratory values, vital signs, qualitative values, measured values & interpretation.

Use Cases

Common healthcare use cases include:

Clinical Decision Making

Medical errors are among the most common causes of death in Western countries. One of the reasons is the lack of relevant information at the right time. In the meantime, medical knowledge doubles every 100 days. Doctors can no longer keep all knowledge about diseases, therapies, drugs and their interactions in mind. The use of information technology is therefore indispensable in hospitals and medical practices. However, existing information systems are often isolated and health data cannot be systematically evaluated. A solution is provided by the use of artificial intelligence in combination with NLP (Natural Language Processing). Large amounts of health-related information from different sources and formats can be linked and analyzed. This knowledge can be made available wherever medical decisions have to be made.

Real World Studies

The use of electronic patient data has a lasting impact on medical research. Routine medical data can be used to conduct retrospective observational and comparative studies. Much of the information needed in clinical research, such as diagnoses and symptoms, treatment history, functional values, etc., is often only available in free text. When this data is extracted from the texts and made available in a structured and semantically normalized form, many studies become possible in the first place, as many more clinical parameters are available, and more patients can be included in the studies.

Coding & Billing

With the introduction of Diagnoses Related Groups (DRGs), the coding and billing of medical and nursing services has changed significantly. The documentation and coding of medical and nursing services is complex and prone to errors. At the same time, this is a very repetitive and time-consuming process since many patients with the same diagnoses are coded in the same way several times a year. With Health Discovery, missing codes and documentation gaps can be identified quickly and accurately. It enables an automated search for diagnoses and procedures and provides corresponding documents in the texts. You no longer have to manually process large amounts of clinical data and can concentrate on the essentials of your work.

Getting Started

The API free plan includes 50,000 units per month for free (1 unit = 100 characters). Sign up at https://averbis.ai (no credit card required) to get API access.

Example

The following example shows a basic API request to extract medical facts from unstructured text in german language.

Request:

curl -X POST "https://api.eu.averbis.ai/detectCoreMedicalEntities?language=de" \
-H "Content-Type: text/plain" \
-H "x-api-key: YOUR_API_KEY" \
-d "Der Patient leidet unter einer Struma diffusa, welche mit Jodid 200µg 1-0-0 behandelt wird. Keine Anzeichen auf Bluthochdruck, derzeitiger Blutdruck 120/80."

Response:

{
  "diagnoses": [
    {
      "begin": 31,
      "end": 45,
      "coveredText": "Struma diffusa",
      "codes": [
        {
          "code": "E04.0",
          "descriptor": "Nichttoxische diffuse Struma",
          "system": "ICD-10-GM",
          "version": "2023"
        }
      ],
      "clinicalStatus": {
        "code": "90734009",
        "descriptor": "Chronic (qualifier value)",
        "system": "SNOMED-CT"
      }
    },
    {
      "begin": 112,
      "end": 125,
      "coveredText": "Bluthochdruck",
      "codes": [
        {
          "code": "I10.90",
          "descriptor": "Essentielle Hypertonie, nicht näher bezeichnet: Ohne Angabe einer hypertensiven Krise",
          "system": "ICD-10-GM",
          "version": "2023"
        }
      ],
      "verificationStatus": {
        "code": "410594000",
        "descriptor": "Definitely NOT present (qualifier value)",
        "system": "SNOMED-CT"
      },
      "clinicalStatus": {
        "code": "90734009",
        "descriptor": "Chronic (qualifier value)",
        "system": "SNOMED-CT"
      }
    }
  ],
  "medications": [
    {
      "begin": 58,
      "end": 75,
      "coveredText": "Jodid 200µg 1-0-0",
      "drugs": [
        {
          "code": "157400",
          "descriptor": "Kaliumiodid",
          "system": "ABDAmed",
          "version": "202306"
        }
      ],
      "dosage": [
        {
          "begin": 64,
          "end": 75,
          "coveredText": "200µg 1-0-0"
        }
      ],
      "atcCodes": [
        {
          "code": "H03CA01",
          "descriptor": "Iodide",
          "system": "ATC-A",
          "version": "2023"
        }
      ]
    }
  ],
  "observations": [
    {
      "begin": 139,
      "end": 155,
      "coveredText": "Blutdruck 120/80",
      "codes": [
        {
          "code": "LP40259-1",
          "descriptor": "Blutdruck",
          "system": "Averbis-Lab-Terminology"
        }
      ],
      "components": [
        {
          "begin": 149,
          "end": 152,
          "coveredText": "120",
          "codes": [
            {
              "code": "LP72836-7",
              "descriptor": "Intravascular systolic",
              "system": "Averbis-Lab-Terminology"
            }
          ]
        },
        {
          "begin": 153,
          "end": 155,
          "coveredText": "80",
          "codes": [
            {
              "code": "LP72831-8",
              "descriptor": "Intravascular diastolic",
              "system": "Averbis-Lab-Terminology"
            }
          ]
        }
      ]
    }
  ]
}

API Access

General Information

The Averbis API is accessible through a HTTP interface. Unless noted otherwise, all endpoints support synchronous POST method requests. Request parameters and body are used to pass information to the API, results are returned in JSON. All request parameters must be UTF-8 encoded, results are also encoded in UTF-8. HTTP status codes are used to signal errors. Authentication is based on fixed API keys, data transport is secured by SSL.

Authentication

The Averbis API uses API keys to authenticate requests. Each request must provide the API key in the x-api-key header field. API requests without authentication will fail with a HTTP error code 403. Do not share your secret API keys in publicly accessible areas such as GitHub, client-side code, and so forth. All API requests must be made over HTTPS. Calls made over plain HTTP will fail.

Sign up for free at http://averbis.ai (no credit card required) to obtain an API key. The API free plan includes 50,000 units per month for free (1 unit = 100 characters).

Limits and Quotas

The following limits and quotas apply:

  • The max allowed text length in the request body is 10000 (UTF-8 encoded) characters. Larger requests will be rejected with a 413 HTTP error code. Empty requests with no text will be rejected with a 400 HTTP error code.

  • The free beta plan includes 50,000 units (1 unit = 100 characters). If your quota has been exhausted, the API returns the HTTP error code 402 and a message that you have exceeded your limit. Please contact Averbis support to request a quota increase.

  • In the free beta plan, a rate limiting of one request per second is applied to each user. If you receive the HTTP error code 429, your application has been throttled and should be configured to resend the request again later.

Supported Languages

German (de). More Languages are coming soon.

Medical Entity Detection

Detect core medical entities

The detectCoreMedicalEntities API endpoint detects standard medical entities, such as diagnosis, medications and observations from unstructured medical text.

INFO: A detailed response schema specification and description is located in the green 200 OK box in the Responses section below.

SecurityApiKey
Request
query Parameters
language
required
string (language)

The text language. This parameter is required.

Value: "de"
Example: language=de
Request Body schema: text/plain; charset=utf-8

The unstructured text to be analyzed.

string (text) [ 1 .. 10000 ] characters

UTF-8 encoded plain text with a length between 1 and 10000 characters.

Responses
200

OK (Expand for response schema specification and documentation)

Response Schema: application/json
required
Array of objects (Diagnosis)

The detected diagnoses entities. The array is empty if no diagnoses have been detected.

required
Array of objects (Medication)

The detected medication entities. The array is empty if no medications have been detected.

required
Array of objects (Observation)

The detected observation entities. The array is empty if no observations have been detected.

400

Bad request - Empty request payload or unsupported language.

402

Payment required - Free plan quota exceeded.

403

Forbidden - Authorization information missing or invalid.

413

Payload too large - Text length in the request exceeded the size limit.

429

Too many requests - Please wait and resend your request.

500

Internal error - Something went wrong on Averbis side.

post/detectCoreMedicalEntities
Request samples
import requests

url = "https://api.eu.averbis.ai/detectCoreMedicalEntities"

query = {
    "language": "de"
}

payload = '''
  YOUR_TEXT_HERE
'''

headers = {
    "Content-Type": "text/plain; charset=utf-8",
    "x-api-key": "YOUR_API_KEY_HERE"
}

response = requests.post(url, data=payload.encode("UTF-8"), headers=headers, params=query)

data = response.json()
print(data)
Response samples
application/json
{
  • "diagnoses": [
    • {
      }
    ],
  • "medications": [
    • {
      }
    ],
  • "observations": [
    • {
      }
    ]
}