LinTO Studio SDK

LinTO Studio SDK is a wrapper around LinTO Studio API. You can generate an auth token from LinTO Studio in the organization settings.

It is available in Python and Javascript (NodeJS and web browser).

Install

Python

pip install linto

NodeJS or compiled front-end project

npm install @linto-ai/linto

Plain JS in web browser

<script type="module" src="https://unpkg.com/@linto-ai/linto/index.js"></script>

Quick start

NodeJS or Web browser

// NodeJS
import LinTO from "@linto-ai/linto"
let linTO = new LinTO({
  authToken: "authToken",
})

// Browser
let linTO = new window.LinTO({
  authToken: "authToken",
})

// Choose depending on your environment

// NodeJS
import fs from "fs"
const file = await fs.openAsBlob("path/to/audio.mp3")

// Browser :
// From an <input type='file'/>
const file = document.getElementById("file").files[0]

const handle = await linTO.transcribe(file)

handle.addEventListener("update", (e) => {
  console.log("Audio transcription processing", e.detail)
})

handle.addEventListener("done", (e) => {
  console.log("Audio transcription completed")
  console.log("Full text", e.detail.fullText)
  console.log("Formated output", e.detail.toFormat())
  console.log("Turns list", e.detail.turns)
  console.log("Api response", e.detail.response)
})

handle.addEventListener("error", () => {
  console.log("Error while processing the audio")
})

Full example

• NodeJS
• Browser

Python

import os
from linto import LinTO

linTO = LinTO(auth_token="auth_token")

with open("path/to/audio.mp3", "rb") as f:
    file = f.read()

handle = await linTO.transcribe(file)

def on_update(data):
    print("Audio transcription processing", data)

def on_done(data):
    print("Audio transcription completed")
    print("Full text", data.full_text)
    print("Formated output", data.to_format())
    print("Turns list", data.turns)
    print("Api response", data.response)

def on_error(data):
    print("Error while processing the audio")

handle.on("update", on_update)
handle.on("done", on_done)
handle.on("error", on_error)

See complete python script at python/test.py

API reference

Method names and options in camelCase are the same in snake_case for Python (e.g. enableDiarization → enable_diarization, setConversationOwner → set_conversation_owner).

Initialisation

// Javascript
const linTO = new LinTO({ authToken: "auth_token", ...options })

# Python
linTO = LinTO(auth_token="auth_token", **options)

Options

Parameter	required	value	description	default value
authToken	yes	String	Studio auth token
baseUrl	no	String	Studio API base url	https://studio.linto.ai/cm-api

---

Transcription

transcribe

Upload a media file and start a transcription job. Returns a polling handle that emits update, done, and error events.

// Javascript
const handle = await linTO.transcribe(file, { ...options })

handle.addEventListener("update", callback)
handle.addEventListener("done", callback)
handle.addEventListener("error", callback)

# Python
handle = await linTO.transcribe(file, **options)

handle.on("update", callback)
handle.on("done", callback)
handle.on("error", callback)

Parameter	required	value	description	default value
file	yes	File or Blob	Audio file to transcribe
enableDiarization	no	Bool	Enable speaker diarization	True
numberOfSpeaker	no	Int	Number of speakers for diarization, 0 means auto	0
language	no	2 letters language code or "*"	Language the audio should be transcribed. "*" means auto-detection + multiple languages	"*"
enablePunctuation	no	Bool	Enable automatic punctuation recognition	True
name	no	String	Name of the media in LinTO Studio	"imported file ${date}"
membersRight	no	Int	Default permission bitmask for organization members on the resulting conversation (1 = read)	None

listServices

List ASR (speech-to-text) services available to the current account. Each service exposes a service_name field that can be referenced elsewhere.

// Javascript
const services = await linTO.listServices()

# Python
services = await linTO.list_services()

---

LLM summaries

listLlmServices

List LLM services available for summarization.

// Javascript
const services = await linTO.listLlmServices()

# Python
services = await linTO.list_llm_services()

summarize

Trigger an LLM summary and return a polling handle. Events are the same shape as transcribe: update, done (with { content, jobId }), error.

// Javascript
const handle = await linTO.summarize(conversationId, serviceRoute, { ...options })

handle.addEventListener("done", (e) => console.log(e.detail.content))

# Python
handle = await linTO.summarize(conversation_id, service_route, **options)

handle.on("done", lambda e: print(e["content"]))

Parameter	required	value	description	default value
conversationId	yes	String	Target conversation id
serviceRoute	yes	String	LLM service route (see listLlmServices)
flavor	no	String	Optional flavor / preset name	None

---

Export & download

downloadConversation

Download the raw transcription (no LLM step). Binary formats (docx, odt, verbatim) return a Blob (browser) or ArrayBuffer (Node); other formats return JSON.

// Javascript
const blob = await linTO.downloadConversation(conversationId, { format: "docx" })

# Python
content = await linTO.download_conversation(conversation_id, format="docx")

Parameter	required	value	description	default value
conversationId	yes	String	Target conversation id
format	no	String	"docx", "odt", "json", ...	"docx"

getExportList

List existing export jobs attached to a conversation.

// Javascript
const jobs = await linTO.getExportList(conversationId)

# Python
jobs = await linTO.get_export_list(conversation_id)

getExportContent

Fetch the content of a finished export job.

// Javascript
const content = await linTO.getExportContent(conversationId, jobId)

# Python
content = await linTO.get_export_content(conversation_id, job_id)

getPublicationTemplates

List publication templates available on the organization.

// Javascript
const templates = await linTO.getPublicationTemplates()

# Python
templates = await linTO.get_publication_templates()

getTemplatePlaceholders

Get placeholders defined on a publication template.

// Javascript
const placeholders = await linTO.getTemplatePlaceholders(templateId)

# Python
placeholders = await linTO.get_template_placeholders(template_id)

exportWithTemplate

Render a publication template to a downloadable document.

// Javascript
const file = await linTO.exportWithTemplate(jobId, { ...options })

# Python
file = await linTO.export_with_template(job_id, **options)

Parameter	required	value	description	default value
jobId	yes	String	Source export job id
format	no	String	Output format	"pdf"
templateId	no	String	Publication template id	None
versionNumber	no	Int	Template version	None

---

Taxonomy

A LinTO Studio organization can group media in two complementary ways:

• Categories & tags: a category holds a flat list of tags; each conversation can carry any number of tags. The built-in "tags" category is the one whose entries surface as chips on media cards.
• Folders: a hierarchical tree; each conversation can live in at most one folder.

listCategories

List taxonomy categories on the current organization.

// Javascript
const categories = await linTO.listCategories()

# Python
categories = await linTO.list_categories()

listTags

List tags inside a category.

// Javascript
const tags = await linTO.listTags(categoryId)

# Python
tags = await linTO.list_tags(category_id)

createTag

Create a tag inside a category.

// Javascript
const tag = await linTO.createTag(categoryId, name, { ...options })

# Python
tag = await linTO.create_tag(category_id, name, **options)

Parameter	required	value	description	default value
categoryId	yes	String	Parent category
name	yes	String	Tag name
color	no	String	Hex color	None
emoji	no	String	Unicode emoji	None

ensureTag

Return the id of tag name, creating it if needed. Defaults to the built-in "tags" category, falling back to the first available category if the named one is missing. Returns null when no category exists at all.

// Javascript
const tagId = await linTO.ensureTag("important")
await linTO.addConversationTag(conversationId, tagId)

# Python
tag_id = await linTO.ensure_tag("important")
await linTO.add_conversation_tag(conversation_id, tag_id)

Parameter	required	value	description	default value
name	yes	String	Tag name (case-insensitive lookup)
categoryName	no	String	Category to look into	"tags"
color	no	String	Color used if the tag has to be created	None
emoji	no	String	Emoji used if the tag has to be created	None

addConversationTag

Append a tag to a conversation, preserving existing tags.

// Javascript
await linTO.addConversationTag(conversationId, tagId)

# Python
await linTO.add_conversation_tag(conversation_id, tag_id)

listFolders

List folders on the current organization.

// Javascript
const folders = await linTO.listFolders()

# Python
folders = await linTO.list_folders()

createFolder

Create a folder.

// Javascript
const folder = await linTO.createFolder(name, { ...options })

# Python
folder = await linTO.create_folder(name, **options)

Parameter	required	value	description	default value
name	yes	String	Folder name
parentId	no	String	Parent folder id (root if omitted)	None
color	no	String	Hex color	None
emoji	no	String	Unicode emoji	None
visibility	no	"public" / "private"	Folder visibility for members below MAINTAINER	"public"

ensureFolder

Return the id of folder name, creating it if needed. Matches on (name, parentId) so the same name at different levels stays distinct. With visibility: "private", the service account becomes the owner and moved conversations are hidden from members below MAINTAINER.

// Javascript
const folderId = await linTO.ensureFolder(name, { ...options })

# Python
folder_id = await linTO.ensure_folder(name, **options)

Parameter	required	value	description	default value
name	yes	String	Folder name
parentId	no	String	Match within this parent folder (root if omitted)	None
visibility	no	"public" / "private"	Visibility used if the folder has to be created	"public"

moveToFolder

Move a conversation into a folder.

// Javascript
await linTO.moveToFolder(folderId, conversationId)

# Python
await linTO.move_to_folder(folder_id, conversation_id)

---

Sharing & users

shareConversation

Share a conversation with a user by email. By default LinTO Studio sends a notification email — pass notify: false to suppress it.

// Javascript
await linTO.shareConversation(conversationId, email, { ...options })

# Python
await linTO.share_conversation(conversation_id, email, **options)

Parameter	required	value	description	default value
conversationId	yes	String	Target conversation id
email	yes	String	Recipient email
right	no	Int	Permission bitmask (1 = read)	1
notify	no	Bool	Send notification email	True

searchUsers

Search users by email or display name. Mostly useful as a building block for higher-level helpers like setConversationOwner.

// Javascript
const users = await linTO.searchUsers(search)

# Python
users = await linTO.search_users(search)

updateConversation

Patch arbitrary conversation fields (e.g. owner, sharedWithUsers, tags). Mostly useful as a building block — prefer the specialized helpers when one exists.

// Javascript
await linTO.updateConversation(conversationId, { owner: userId, tags: [tagId] })

# Python
await linTO.update_conversation(conversation_id, {"owner": user_id, "tags": [tag_id]})

setConversationOwner

Transfer conversation ownership to the user matching email. Resolves the user via searchUsers, then sets owner and clears sharedWithUsers. Returns the resolved user id, or null if the email cannot be matched.

// Javascript
const userId = await linTO.setConversationOwner(conversationId, "alice@example.com")
if (!userId) console.warn("user not found")

# Python
user_id = await linTO.set_conversation_owner(conversation_id, "alice@example.com")
if not user_id:
    print("user not found")

---

Media output

The object emitted on the done event of transcribe exposes the helpers below.

Property / method	description
fullText	Plain text of the full transcript (no speaker, language or timestamp metadata).
turns	Array of { speaker, lang, text, stime, etime } objects.
response	Raw API response (escape hatch for fields the SDK doesn't surface).
toFormat(opts)	Render the transcript as a single string with configurable metadata and separators.

toFormat options

Parameter	required	value	description	default value
sep	no	String	Separator between metadatas	" - "
metaTextSep	no	String	Separator between metadata and text	" : "
eol	no	String	End of line character ("CRLF" or "LF" or None). If neither "CRLF" or "LF", no carriage return is added.	"CRLF"
ensureFinalEOL	no	Bool	Whether to ensure final end of line	false
include	no	Object	Which metadata to include (speaker, lang, timestamp)	{ speaker: true, lang: true, timestamp: true }
order	no	Array	Order of metadata in output	["speaker", "lang", "timestamp"]

Coming soon 🏗️

Transcribe video conference

const meeting = await linTO.transcribeVideoConference({ type, url, ...options })
meeting.addEventListener("connected", callback)
meeting.addEventListener("meeting_start", callback)
meeting.addEventListener("people_join", callback)
meeting.addEventListener("meeting_end", callback)
meeting.addEventListener("transcription", callback)

handle = await meeting.offlineTranscription({ ...options })
handle.addEventListener("update", callback)
handle.addEventListener("done", callback)
handle.addEventListener("error", callback)

Live transcription

const live = await linTO.transcribeLive({ ...option })
live.connectAudio(source)
live.startTranscription()
live.stopTranscription()
live.addEventListener("transcription", callback)