Skip to main content
Follow these steps to get access and start building:
1

Starting from a clean slate

To install the Corti SDK you can use Node Package Manager (npm) in a terminal of your choosing:
  1. Install Node.js and npm (detailed instructions available here)
  2. Open a terminal and run npm install @corti/sdk
  3. Start using the JavaScript SDK!
View the package details and latest version on npm.
To check if you have npm installed, run npm -v and a version number should be returned. If it fails, then reinstall npm from the link above or try restarting your computer.
Before making requests, you’ll need to set up a CortiClient. This handles authentication with the Corti API.If you already have client credentials for your API project, you can initialize the client like this:
import { CortiEnvironment, CortiClient } from "@corti/sdk";

new CortiClient({
    environment: CortiEnvironment.Eu,
    auth: {
        clientId: CLIENT_ID,
        clientSecret: CLIENT_SECRET
    },
    tenantName: TENANT
});
Still need to create an API project and client credentials? Learn more here!

2

Authentication

Authentication is governed by OAuth 2.0 using client credentials grant type. This authentication protocol offers enhanced security measures, ensuring that access to patient data and medical documentation is securely managed and compliant with healthcare regulations.
The client credentials flow shown below is intended for backend/server-side applications only. For frontend applications, you should use access tokens instead of exposing client secrets. See the Authentication Guide for frontend authentication patterns.
  1. Obtain your API client credentials from the Corti API Console.
  2. Add the client_id and client_secret to your project. 
    import { CortiEnvironment, CortiClient } from "@corti/sdk";

new CortiClient({
    environment: CortiEnvironment.Eu,
    auth: {
        clientId: CLIENT_ID,
        clientSecret: CLIENT_SECRET
    },
    tenantName: TENANT
});
  3. Start making API calls and requests from this client!
For best performance, create a single CortiClient instance and reuse it throughout your application. Avoid re-initializing a new client for every request.
Click here to read more about how to appropriately use OAuth for your workflow needs and proper handling of client_secret.
For comprehensive authentication examples and advanced configuration options, see the Authentication Guide in the SDK repository.
3

Testing your client

JavaScript code example of using the client to authenticate and create an interaction:
Creating an interaction
import { CortiEnvironment, CortiClient } from "@corti/sdk";

const client = new CortiClient({
    environment: CortiEnvironment.Eu,
    auth: {
        clientId: CLIENT_ID,
        clientSecret: CLIENT_SECRET
    },
    tenantName: TENANT
});
  
const { interactionId } = await client.interactions.create({
    encounter: {
        identifier: "YOUR_IDENTIFIER",
        status: "planned",
        type: "first_consultation"
    }
});
Find the full specification for create interaction request in the API Reference

4

Building a complete workflow

Goal: Integrate with Corti SDK to enable an ambient documentation, AI scribe workflow application
DecisionIntegration Planning
1How will audio be processed - real-time web socket connection, via /stream API (recommended) or asynchronous processing, via /recordings and `/transcripts APIs?To use the /stream API, follow the path for real-time ambient documentation; to use the /recordings and /transcripts APIs, follow the path of asynchronous ambient documentation.
2What template(s) will be used in document generation workflow?Use the GET/templates request to see available templates. In addition to accessing Corti-default templates, you can add the ?org= filter to find templates available to your specific organization.
3Will document be generated based on Facts (recommended), transcript, or string?Designing around Facts, transcript, or string will determine how to use the context variable in the Generate Document request.
4Will EHR context or other data be used as Facts in document generation?If yes, then use the Add Facts request to support the context updates.
5How will the output be integrated into EHR or other target systems?Document output will be a json object that can be saved as a full note, or parsed by section so that text can be directed to appropriate fields in the target system.
The first step will be to create an interaction, as shown above. Once you’ve created your interaction, the interaction ID can be used for the steps that follow below.
See more details about this workflow here and the full API specifications here.
1

Upload a recording

Here is where you use the interaction ID.
upload recording
await client.recordings.upload(file, "INTERACTION ID");
Create a helper function to upload a recording:
full function
import { createReadStream } from "fs";

async function uploadRecording(client, interactionId, filePath){
    const file = createReadStream(filePath, {autoClose: true});
    return client.recordings.upload(file, interactionId);
}
The createReadStream import is used to create a readable stream from a file path.Find the full specification for uploading a recording in the API reference.
2

Generate a transcript

Here you’ll need the interactionId as well as the recordingId returned from the upload response.
Generate a transcript
const { recordingId } = await uploadRecording(client, interactionId, "sample.mp3") 
const transcript = await client.transcripts.create(interactionId, {
    recordingId: recordingId,
    primaryLanguage: "en"
});
Find the full specification for generating a transcript in the API reference
3

Generating a document

Here you need the interactionId and transcript text (transcript) from the previous step.
Generate a Document
const document = await client.documents.create(interactionId, {
    context: [{
        type: "string",
        data: transcript.transcripts.map(t => t.text).join(" "),
    }],
    templateKey: "soap",
    outputLanguage: "en",
});
Find the full specification for generating a document in the API reference
4

Retrieving the document

If you need to retrieve a generated document again or at a later time (since the create call already returns the document), you can do so using the interactionId and documentId from the previous step.
Get a Document
await client.documents.get("INTERACTION ID", "DOCUMENT ID");
Find the full specification for retrieving a document in the API reference here
5

Putting it all together

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

dotenv.config();

const { CLIENT_ID, CLIENT_SECRET, TENANT_NAME: TENANT } = process.env;

const client = new CortiClient({
    environment: CortiEnvironment.Eu,
    auth: { clientId: CLIENT_ID, clientSecret: CLIENT_SECRET },
    tenantName: TENANT,
});

const { interactionId } = await client.interactions.create({
    encounter: {
        identifier: "GUID OF YOUR CHOOSING",
        status: "planned",
        type: "first_consultation",
    },
});

const { recordingId } = await client.recordings.upload(
    fs.createReadStream("sample.mp3", { autoClose: true }),
    interactionId
);

const transcript = await client.transcripts.create(interactionId, {
    recordingId,
    primaryLanguage: "en"
});

const document = await client.documents.create(interactionId, {
    context: [{ 
        type: "string",
        data: transcript.transcripts.map(t => t.text).join(" "),
    }],
    templateKey: "soap",
    outputLanguage: "en",
});

console.log(document.name);
The dotenv import loads environment variables from a .env file. This keeps sensitive values like your client ID and client secret out of your source code, which is considered best practice.

​
Additional Resources

For support or questions, please reach out via help.corti.ai.
To get access to Corti API click here to sign up