// skippable values in lowercase
const tags = ["stream"];
const patterns = ["stream", "wss"];
const patches = {
    documents: {
        headPattern: "generate",
        contextData: {
            0: "Facts[]",
            1: "Transcript",
            2: "string",
        }
    }
};

const watchContentContainer = () => {
    const observer = new MutationObserver((mutations, observer) => {
        for (const mut of mutations) {
            if (mut.type !== "childList") {
                continue;
            }
            disablePlaygrounds();
            patchBugDocuments();
            patchTrailingSlash();
            watchDocumentsContextTypeContainer();
        }
    });
    if (!observer) {
        console.error("Failed to create content observer");
        return;
    }

    const target = document.getElementById("content-container");
    if (!target) {
        console.error("Missing #content-container");
        return;
    }

    observer.observe(target, { childList: true });
};

const watchDocumentsContextTypeContainer = () => {
    const docPatch = patches["documents"];
    if (!docPatch) {
        console.error("Missing patch for Documents");
        return;
    }

    const pattern = docPatch["headPattern"];
    if (!docPatch) {
        console.error("Missing header pattern check for Documents");
        return;
    }

    if (shouldSkipPatch([pattern])) {
        return;
    }

    const observer = new MutationObserver((mutations, observer) => {
        for (const mut of mutations) {
            if (mut.type !== "childList") {
                continue;
            }
            patchBugDocuments();
        }
    });
    if (!observer) {
        console.error("Failed to create Documents context observer");
        return;
    }

    const target = document.getElementById("body-context-data");
    if (!target) {
        console.error("Missing #body-context-data");
        return;
    }

    observer.observe(target.parentNode.parentNode, { childList: true });
};

const findContentArea = () => {
    const area = document.getElementById("content-area");
    if (!area) {
        throw new Error("Missing #content-area");
    }
    return area;
};

const disablePlayground = () => {
    try {
        const area = findContentArea();
    } catch (exc) {
        console.error(exc);
    }

    const flexContainer = area.closest("div.flex");
    if (!flexContainer) {
        console.error("Missing playground container");
        return;
    }

    for (const button of flexContainer.getElementsByTagName("button")) {
        if (!button.textContent.toLowerCase().includes("try it")) {
            continue;
        }

        button.style.display = "none";
        return true;
    }
};

const disablePlaygrounds = () => {
    for (const tag of tags) {
        for (const head of document.getElementsByClassName("eyebrow")) {
            if (!head.textContent.toLowerCase().includes(tag)) {
                continue;
            }

            if (disablePlayground()) {
                return;
            }
        }
    }

    for (const pattern of patterns) {
        for (const head of document.getElementsByTagName("h1")) {
            if (!head.textContent.toLowerCase().includes(pattern)) {
                continue;
            }

            if (disablePlayground()) {
                return;
            }
        }
    }
};

const patchPlayground = () => {
    try {
        const area = findContentArea();
    } catch (exc) {
        console.error(exc);
    }

    const flexContainer = area.closest("div.flex");
    if (!flexContainer) {
        console.error("Missing playground container");
        return;
    }

    for (const button of flexContainer.getElementsByTagName("button")) {
        if (!button.textContent.toLowerCase().includes("try it")) {
            continue;
        }

        button.style.display = "none";
        return true;
    }
};

const shouldSkipPatch = (patterns) => {
    for (const head of document.getElementsByTagName("h1")) {
        for (const pattern of patterns) {
            if (head.textContent.toLowerCase().includes(pattern)) {
                return false;
            }
        }
    }
    return true;
};

const patchBugDocuments = () => {
    const docPatch = patches["documents"];
    if (!docPatch) {
        console.error("Missing patch for Documents");
        return;
    }

    const pattern = docPatch["headPattern"];
    if (!docPatch) {
        console.error("Missing header pattern check for Documents");
        return;
    }

    if (shouldSkipPatch([pattern])) {
        return;
    }

    const data = document.getElementById("body-context-data");
    if (!data) {
        console.error("Missing #body-context-data");
        return;
    }

    for (const select of data.getElementsByTagName("select")) {
        const options = Array.from(
            select.getElementsByTagName("option")
        ).entries();

        for (const [idx, option] of options) {
            const contextPatch = docPatch["contextData"];
            if (!contextPatch) {
                console.error("Missing patch for Documents context");
                return;
            }

            const optionPatch = contextPatch[idx];
            if (!optionPatch) {
                console.error(`Missing patch for context option ${idx}`);
                return;
            }

            option.textContent = optionPatch;
        }
    }
};

const patchTrailingSlash = () => {
    const patterns = [
        "interaction", "recording", "transcript", "fact", "document", "code"
    ];
    if (shouldSkipPatch(patterns)) {
        return;
    }

    const badElement = document.getElementById("header")?.nextSibling;
    if (!badElement) {
        console.error("Missing playground widget");
    }

    if (badElement.innerText.split("\n")[0].toUpperCase() !== "POST") {
        return;
    }

    const layers = 4;
    let target = badElement;
    for (let idx = 0; idx < layers; idx++) {
        if (target.children.length === 0) {
            console.error("Missing playground section");
            return;
        }
        target = target.children[0];
    }

    let parts;
    try {
        parts = target.children[1].children[0].children;
    } catch (err) {
        console.error("Missing playground parts");
        console.error(err);
        return;
    }

    // Mintlify mangling the schema
    if (parts[parts.length - 1].innerHTML.endsWith("/")) {
        return;
    }
    parts[parts.length - 1].innerHTML = parts[parts.length - 1].innerHTML + "/";
};

window.addEventListener("load", () => {
    disablePlaygrounds();
    patchBugDocuments();
    patchTrailingSlash();
    watchContentContainer();
    watchDocumentsContextTypeContainer();
})


 Upload a recording for a given interaction. There is a maximum limit of 60 minutes in length and 150MB in size for recordings.

Upload Recording

Recording

AuthorizationHeader

Returns the recording ID in the response.

Corti API Documentation

Welcome

Welcome to the Corti API

Learn how to authenticate to the Corti API and make your first request

Quickstart

Use the self-service console to sign up and start your free trial today

Get access

Overview of Corti application programming interfaces (API)

Introduction

How it works

Real-time healthcare AI clinical reasoning system

FactsR™

Learn about the speech recognition endpoints in the Corti API

Speech recognition

Overview of Corti speech recognition

Learn about how languages are supported in Corti APIs

Languages

Introduction to working with Corti templates for document generation

Overview

Using Corti's default out of the box templates

Standard templates

Generate documents with templates using facts or transcripts

Standard document generation

Custom template definition and document requests

Advanced document generation

Template request process

Creating a text document from a pre-recorded audio file

Transcription

Live conversational transcript, fact extraction, and note generation

Real-time ambient documentation

Ambient note generation from audio recording and conversational transcript

Asynchronous ambient documentation

Let us handle microphone device management and connecting with the API

Dictation SDK

WebSocket Secure (WSS) API Documentation for /stream endpoint

Real-time conversational fact extraction

Real-time conversational transcript generation and fact extraction (FactsR™)

WebSocket Secure (WSS) API Documentation for /transcribe endpoint

Real-time stateless dictation

 Lists all existing interactions. Results can be filtered by encounter status and patient identifier.

List All Interactions

Create Interaction

 Retrieves a previously recorded interaction by its unique identifier (interaction ID).

Get Existing Interaction

Delete Interaction

 Modifies an existing interaction by updating specific fields without overwriting the entire record.

Update Interaction

 Retrieve a list of recordings for a given interaction.

List Recordings

 Retrieve a specific recording for a given interaction.

Get Recording

 Delete a specific recording for a given interaction.

Delete Recording

 Retrieves a list of transcripts for a given interaction.

List Transcripts

 Creates a new transcript for an interaction.

Create Transcript

 Retrieves the transcript for a specific interaction.

Get Transcript

 Deletes a specific transcript associated with an interaction.

Delete Transcript

List Fact Groups

 Retrieves a list of facts for a given interaction.

List Facts

Add Facts

 Updates multiple facts associated with an interaction. If the interaction `status = "in progress"`, the updated facts will be sent to the client over WebSocket.

Update Facts

 Updates an existing fact within a specific interaction. If the interaction `status = "in progress"`, the updated fact will be sent to the client via WebSocket. To discard a fact, simply set `discarded = true`.

Update Fact

List Documents

Generate Document

Get Document

Delete Document

Update Document

 Retrieves a list of template sections with optional filters for organization and language.

List Template Sections

 Retrieves a list of templates with optional filters for organization, language, and status.

List Templates

Get Template

 Get all codes associated with an interaction.

List Codes

Select Codes

Generate Codes

 Compares two reference texts, a 'source' document and a 'target' document, and returns a percentage alignment, optionally including aligned segments.

Alignment Model

 This endpoint is used for binary classification tasks: comparing two resources, where a boolean output is expected.

Classify Binary

 Allows users to ask questions or make queries in the context of a specific interaction. This endpoint supports Server-Sent Events (SSE) for real-time updates and responses. The thread ID, which is returned with the initial query, allows users to ask follow-up questions or refine their queries. This endpoint is designed to facilitate dynamic and context-aware conversations, making it suitable for applications such as chatbots, virtual assistants, research tools and workflow augmentation.

Chat

 Access and unlock knowledge bases and guidelines tools queries, documents, or interactions. This endpoint is designed to facilitate the retrieval of relevant information from various sources, enabling users to access and utilize knowledge bases and guidelines effectively. The response includes a summary and a list of relevant sources, providing users with a comprehensive overview of the retrieved information.

Retrieval

 Provides a list of suggested questions based on a query and/or interaction context.

Predictive Prompt

 Finds mentions of defined content within a set of reference texts.

Explainability Model

 JSON representation of the API documentation.

Swagger JSON

Find the latest updates across Corti's products

Welcome to the resource center

Help

Updates and improvements to Corti application programming interfaces (API).

API Updates

Updates and improvements to language models supported by Corti automated speech recognition (ASR).

ASR Updates

AI Platform

Errors

Choosing the Right OAuth2 Flow for Corti Integrations

Working with OAuth

Learn how to authenticate to the Corti API

API Authentication

Updates and improvements to Corti foundation models. More information is available [here](https://www.corti.ai/foundation-models).

Foundation Model Updates

Updates and improvements to Corti application programming interfaces (API). Detailed API documentation is available [here](/api-reference/).

Updates and improvements to language models supported by Corti automated speech recognition (ASR). Detailed language documentation is availabile [here](/about/languages/).

Language Updates

WebSocket Secure (WSS) API Documentation for /stream endpoint in support of real-time conversational transcript and fact generation

Real-time transcript and Fact generation

WebSocket Secure (WSS) API Documentation for stateless use of /transcribe endpoint for real-time speech-to-text

Get Started

Live Streams

interactions

recordings

transcripts

facts

documents

templates

codes

alignment

classification

contextual

explainability

swagger

Upload Recording

Authorizations

Headers

Path Parameters

Body

Response