Text Generation API

Clinical note generation API built for healthcare

Turn transcripts, facts, or structured data into any type of clinical documentation via API. Tailored to your format, specialty, and language.

Get API key Meet with an Expert

Generate structured clinical documents with a few lines of code

cURLJavaScriptPythonPHPGoJava

curl --request POST \
  --url https://api.{environment}.corti.app/v2/interactions/{id}/documents/ \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --header 'Tenant-Name: <tenant-name>' \
  --data '{
  "context": [
    {
      "type": "facts",
      "data": [
        {
          "text": "<string>",
          "group": "Others",
          "source": "core"
        }
      ]
    }
  ],
  "templateKey": "<string>",
  "name": "<string>",
  "modelName": "\"model_name (Latest)\" | \"model_name_version\"",
  "outputLanguage": "<string>"
}'

import { CortiEnvironment, CortiClient } from "@corti/sdk";

const client = new CortiClient({
    environment: CortiEnvironment.Eu,
    auth: {
        clientId: "YOUR_CLIENT_ID",
        clientSecret: "YOUR_CLIENT_SECRET"
    },
    tenantName: "YOUR_TENANT_NAME"
});
await client.documents.create("f47ac10b-58cc-4372-a567-0e02b2c3d479", {
    context: [{
            type: "facts",
            data: [{
                    text: "text",
                    source: "core"
                }]
        }],
    templateKey: "templateKey",
    outputLanguage: "outputLanguage"
});

import requests

url = "https://api.{environment}.corti.app/v2/interactions/{id}/documents/"

payload = {
    "context": [
        {
            "type": "facts",
            "data": [
                {
                    "text": "<string>",
                    "group": "Others",
                    "source": "core"
                }
            ]
        }
    ],
    "templateKey": "<string>",
    "name": "<string>",
    "modelName": "\"model_name (Latest)\" | \"model_name_version\"",
    "outputLanguage": "<string>"
}
headers = {
    "Tenant-Name": "<tenant-name>",
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.post(url, json=payload, headers=headers)

print(response.json())

<?php

$curl = curl_init();

curl_setopt_array($curl, [
  CURLOPT_URL => "https://api.{environment}.corti.app/v2/interactions/{id}/documents/",
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_ENCODING => "",
  CURLOPT_MAXREDIRS => 10,
  CURLOPT_TIMEOUT => 30,
  CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
  CURLOPT_CUSTOMREQUEST => "POST",
  CURLOPT_POSTFIELDS => json_encode([
    'context' => [
        [
                'type' => 'facts',
                'data' => [
                                [
                                                                'text' => '<string>',
                                                                'group' => 'Others',
                                                                'source' => 'core'
                                ]
                ]
        ]
    ],
    'templateKey' => '<string>',
    'name' => '<string>',
    'modelName' => '"model_name (Latest)" | "model_name_version"',
    'outputLanguage' => '<string>'
  ]),
  CURLOPT_HTTPHEADER => [
    "Authorization: Bearer <token>",
    "Content-Type: application/json",
    "Tenant-Name: <tenant-name>"
  ],
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
  echo "cURL Error #:" . $err;
} else {
  echo $response;
}

package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.{environment}.corti.app/v2/interactions/{id}/documents/"

	payload := strings.NewReader("{\n  \"context\": [\n    {\n      \"type\": \"facts\",\n      \"data\": [\n        {\n          \"text\": \"<string>\",\n          \"group\": \"Others\",\n          \"source\": \"core\"\n        }\n      ]\n    }\n  ],\n  \"templateKey\": \"<string>\",\n  \"name\": \"<string>\",\n  \"modelName\": \"\\\"model_name (Latest)\\\" | \\\"model_name_version\\\"\",\n  \"outputLanguage\": \"<string>\"\n}")

	req, _ := http.NewRequest("POST", url, payload)

	req.Header.Add("Tenant-Name", "<tenant-name>")
	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}

HttpResponse<String> response = Unirest.post("https://api.{environment}.corti.app/v2/interactions/{id}/documents/")
  .header("Tenant-Name", "<tenant-name>")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{\n  \"context\": [\n    {\n      \"type\": \"facts\",\n      \"data\": [\n        {\n          \"text\": \"<string>\",\n          \"group\": \"Others\",\n          \"source\": \"core\"\n        }\n      ]\n    }\n  ],\n  \"templateKey\": \"<string>\",\n  \"name\": \"<string>\",\n  \"modelName\": \"\\\"model_name (Latest)\\\" | \\\"model_name_version\\\"\",\n  \"outputLanguage\": \"<string>\"\n}")
  .asString();

Get API key Read the docs

Text generation capabilities

Templated documents
Create clinical notes from transcripts or facts using ready-made templates.
FactsR™
Keeping records precise, relevant, and tightly aligned facts from clinical conversations.
Read the docs
Async generation
Create documents after an interaction by posting transcripts to the API.
Read the docs
Standard templates
Start fast with templates like SOAP, H&P, and Patient Summary, available in multiple languages and kept up to date.
Read the docs
Custom templates
Define your own templates, sections and styles to fit any specialty and workflow.
Read the docs
One-to-many generation
Produce several note types from the same encounter, such as SOAP and patient summary.
Read the docs

Model explainability in healthcare matters

In healthcare, model reasoning paths carry high-stakes implications. Understanding how a model reaches its conclusions is essential for safety, compliance, and trust.

To advance this, Corti’s research team developed the Generative Interpretability Method (GIM), marking a major step forward in mechanistic interpretability.

Across leading architectures like Gemma, LLaMA, and Qwen, GIM achieves over 2× higher faithfulness than existing methods, enabling Corti to build more transparent, auditable, and trustworthy AI infrastructure for high-stakes environments.

Read our research

Bar chart of faithfulness scores: GIM from Corti scores 2.24 on GPT-2, 2.02 on Qwen-2.5, 3.54 on Gemma-2 and 2.54 on Llama-3.1, against 1.10, 0.80, 1.33 and 0.90 for existing methods

Clinical documentation generation tailored to every workflow

Generate accurate clinical notes

Turn transcripts, structured data, or past records into polished documentation automatically. Corti creates SOAP notes, discharge summaries, and follow-up letters in seconds, cutting manual work while ensuring accuracy, consistency, and compliance.

Illustration of a clinical note generated from a transcript

Real-time, ready-to-sign drafts

Generate full drafts seconds after the encounter ends. Clinicians simply review, edit, and sign, reducing hours of admin to minutes without disrupting workflow or accuracy.

Illustration of a ready-to-sign draft note

Flexible, custom templates

Select from our library of clinical templates or define your own with custom sections, terminology, and style. We provide modular and flexible infrastructure, enabling documentation tailored to your users’ specialties and standards.

Illustration of a custom documentation template with editable sections

Multiple outputs from one encounter

Produce different documents from the same interaction: a clinician note for the EHR, a patient summary, and a billing-ready report - all from the same source.

Illustration of several documents generated from one encounter

Multilingual documentation at scale

Generate medical documentation in English, Danish, Spanish, German, French, Swedish, and more. Corti is the trusted foundation for teams building clinician and patient-facing applications with precise multilingual documentation needs.

Illustration of documentation generated in several languages

"By combining Dedalus’ workflow expertise with Corti’s real-time reasoning engine, we’re delivering exactly what clinicians have been asking for - smarter tools that save time and improve care."
Jan Rusch
Director Integrated Technologies, Dedalus

What will you build?

Patient summaries

Generate patient-facing handouts in plain language, directly from the same interaction used to create the clinical note.

Clinical notes

Turn conversations into structured SOAP notes, discharge summaries, H&Ps, or ER reports with clean formatting and no manual typing.

Referral letters

Use specialty-specific templates to auto-generate referral notes, follow-ups, or nursing documentation in your format.

Multi-language output

Generate both a professional note and a patient summary - each in a different language from a single transcript or fact.

Built for healthcare. Trusted by developers.

Claim $50 of free credits when you start building.

Get API key Meet with an expert

Clinical note generation API built for healthcare

Generate structured clinical documents with a few lines of code

Templated documents

FactsR™

Async generation

Standard templates

Custom templates

One-to-many generation