SDK method examples

Examples for every product-facade method on @flowra/sdk and flowra (flowra-sdk on PyPI). Bodies use placeholders — full schemas: API reference. Method map: SDK namespaces. Source: github.com/flowradev/sdk. Assume a client is already constructed:

import { Flowra } from '@flowra/sdk';

const flowra = new Flowra({ apiKey: process.env.FLOWRA_API_KEY! });

from flowra import Flowra

flowra = Flowra(api_key="YOUR_API_KEY")

Ids like toolId, workflowId, and threadId are placeholders from list/create responses. Chat threads use thread_id (snake_case) from Graphify.

Root

`getProfile` / `get_profile`

const result = await flowra.getProfile();

result = flowra.get_profile()

`asUser` / `as_user`

Returns a scoped client.

const alice = flowra.asUser('customer_alice');

alice = flowra.as_user('customer_alice')

`flowra.raw` (example)

Escape hatch.

const result = await flowra.raw.toolsControllerGetTools({ client: flowra.client, query: { limit: 5 } });

result = flowra.request('GET', '/api/v1/tools', query={'limit': 5})

`tools`

`list`

const result = await flowra.tools.list({ limit: 10, toolkitSlug: 'slack' });

result = flowra.tools.list(limit=10, toolkitSlug='slack')

`get`

const result = await flowra.tools.get(toolId);

result = flowra.tools.get(tool_id)

`create`

const result = await flowra.tools.create({ /* CreateToolDto */ });

result = flowra.tools.create({...})

`update`

const result = await flowra.tools.update(toolId, { /* patch */ });

result = flowra.tools.update(tool_id, {...})

`remove`

const result = await flowra.tools.remove(toolId);

result = flowra.tools.remove(tool_id)

`setActive`

const result = await flowra.tools.setActive(toolId);

result = flowra.tools.set_active(tool_id)

`execute`

const result = await flowra.tools.execute('SLACK_SEND_MESSAGE', { arguments: { /* ... */ } });

result = flowra.tools.execute('SLACK_SEND_MESSAGE', {'arguments': {}})

`executionLogs`

const result = await flowra.tools.executionLogs({ limit: 20 });

result = flowra.tools.execution_logs(limit=20)

`toolkits`

`list`

const result = await flowra.toolkits.list({ limit: 20 });

result = flowra.toolkits.list(limit=20)

`listWithTools`

const result = await flowra.toolkits.listWithTools({ q: 'gmail' });

result = flowra.toolkits.list_with_tools(q='gmail')

`get`

const result = await flowra.toolkits.get(toolkitId);

result = flowra.toolkits.get(toolkit_id)

`create`

const result = await flowra.toolkits.create({ /* CreateToolkitDto */ });

result = flowra.toolkits.create({...})

`update`

const result = await flowra.toolkits.update(toolkitId, { /* patch */ });

result = flowra.toolkits.update(toolkit_id, {...})

`remove`

const result = await flowra.toolkits.remove(toolkitId);

result = flowra.toolkits.remove(toolkit_id)

`setActive`

const result = await flowra.toolkits.setActive(toolkitId);

result = flowra.toolkits.set_active(toolkit_id)

`messagingChannels`

const result = await flowra.toolkits.messagingChannels();

result = flowra.toolkits.messaging_channels()

const result = await flowra.toolkits.listCategories();

result = flowra.toolkits.list_categories()

`skills`

`list`

const result = await flowra.skills.list({ limit: 20 });

result = flowra.skills.list(limit=20)

`get`

const result = await flowra.skills.get(skillId);

result = flowra.skills.get(skill_id)

`create`

const result = await flowra.skills.create({ /* CreateSkillDto */ });

result = flowra.skills.create({...})

`update`

const result = await flowra.skills.update(skillId, { /* UpdateSkillDto */ });

result = flowra.skills.update(skill_id, {...})

`remove`

const result = await flowra.skills.remove(skillId);

result = flowra.skills.remove(skill_id)

`addToLibrary`

const result = await flowra.skills.addToLibrary(skillId);

result = flowra.skills.add_to_library(skill_id)

`catalogBrowse`

const result = await flowra.skills.catalogBrowse({ limit: 20 });

result = flowra.skills.catalog_browse(limit=20)

`importGithub`

const result = await flowra.skills.importGithub({ /* ImportGithub body */ });

result = flowra.skills.import_github({...})

`registryInstall`

const result = await flowra.skills.registryInstall({ /* RegistryInstall body */ });

result = flowra.skills.registry_install({...})

`registryList`

const result = await flowra.skills.registryList({ limit: 20 });

result = flowra.skills.registry_list(limit=20)

`registrySearch`

const result = await flowra.skills.registrySearch({ q: 'pdf' });

result = flowra.skills.registry_search(q='pdf')

`workflows`

`list`

const result = await flowra.workflows.list({ limit: 10 });

result = flowra.workflows.list(limit=10)

`get`

const result = await flowra.workflows.get(workflowId);

result = flowra.workflows.get(workflow_id)

`create`

const result = await flowra.workflows.create({ /* CreateAgentDto */ });

result = flowra.workflows.create({...})

`update`

const result = await flowra.workflows.update(workflowId, { /* patch */ });

result = flowra.workflows.update(workflow_id, {...})

`remove`

const result = await flowra.workflows.remove(workflowId);

result = flowra.workflows.remove(workflow_id)

`setActive`

const result = await flowra.workflows.setActive(workflowId, { activeStatus: true });

result = flowra.workflows.set_active(workflow_id, True)

`run`

const result = await flowra.workflows.run(workflowId, { input: { message: 'hi' } });

result = flowra.workflows.run(workflow_id, {'input': {'message': 'hi'}})

`status`

const result = await flowra.workflows.status(threadId);

result = flowra.workflows.status(thread_id)

`resume`

const result = await flowra.workflows.resume(threadId, { resumeValue: { approved: true } });

result = flowra.workflows.resume(thread_id, {'resumeValue': {'approved': True}})

`executions`

const result = await flowra.workflows.executions({ limit: 20 });

result = flowra.workflows.executions(limit=20)

`execution`

const result = await flowra.workflows.execution(executionId);

result = flowra.workflows.execution(execution_id)

`statistics`

const result = await flowra.workflows.statistics(workflowId);

result = flowra.workflows.statistics(workflow_id)

`executionsFor`

const result = await flowra.workflows.executionsFor(workflowId, { limit: 20 });

result = flowra.workflows.executions_for(workflow_id, limit=20)

`addConnection`

const result = await flowra.workflows.addConnection({ /* body */ });

result = flowra.workflows.add_connection({...})

`changeConnection`

const result = await flowra.workflows.changeConnection(workflowId, { /* body */ });

result = flowra.workflows.change_connection(workflow_id, {...})

`setAuthConfig`

const result = await flowra.workflows.setAuthConfig(workflowId, { /* body */ });

result = flowra.workflows.set_auth_config(workflow_id, {...})

`clearAuthConfig`

const result = await flowra.workflows.clearAuthConfig(workflowId, { /* body */ });

result = flowra.workflows.clear_auth_config(workflow_id, {...})

`clearConnection`

const result = await flowra.workflows.clearConnection(workflowId, { /* body */ });

result = flowra.workflows.clear_connection(workflow_id, {...})

`connections`

`list`

const result = await flowra.connections.list();

result = flowra.connections.list()

`listGrouped`

const result = await flowra.connections.listGrouped();

result = flowra.connections.list_grouped()

`create`

const result = await flowra.connections.create({ /* body */ });

result = flowra.connections.create({...})

`createLink`

const result = await flowra.connections.createLink({ toolkitSlug: 'slack', authConfigId });

result = flowra.connections.create_link({'toolkitSlug': 'slack', 'authConfigId': auth_config_id})

`update`

const result = await flowra.connections.update(connectionId, { /* patch */ });

result = flowra.connections.update(connection_id, {...})

`remove`

const result = await flowra.connections.remove(connectionId);

result = flowra.connections.remove(connection_id)

`authConfigs` / `auth_configs`

`list`

const result = await flowra.authConfigs.list({ toolkitSlug: 'slack' });

result = flowra.auth_configs.list(toolkitSlug='slack')

`get`

const result = await flowra.authConfigs.get(authConfigId);

result = flowra.auth_configs.get(auth_config_id)

`create`

const result = await flowra.authConfigs.create({ /* CreateAuthConfigDto */ });

result = flowra.auth_configs.create({...})

`remove`

const result = await flowra.authConfigs.remove(authConfigId);

result = flowra.auth_configs.remove(auth_config_id)

`users`

`list`

const result = await flowra.users.list();

result = flowra.users.list()

`create`

const result = await flowra.users.create({ username: 'customer_alice' });

result = flowra.users.create({'username': 'customer_alice'})

`getByUsername`

const result = await flowra.users.getByUsername('customer_alice');

result = flowra.users.get_by_username('customer_alice')

`toggleActive`

const result = await flowra.users.toggleActive(userId);

result = flowra.users.toggle_active(user_id)

`refreshAvatar`

const result = await flowra.users.refreshAvatar(userId);

result = flowra.users.refresh_avatar(user_id)

`triggers`

`list`

const result = await flowra.triggers.list();

result = flowra.triggers.list()

`upsert`

const result = await flowra.triggers.upsert(slug, { /* UpsertTriggerInstanceDto */ });

result = flowra.triggers.upsert(slug, {...})

`remove`

const result = await flowra.triggers.remove(triggerId);

result = flowra.triggers.remove(trigger_id)

`setStatus`

const result = await flowra.triggers.setStatus(triggerId);

result = flowra.triggers.set_status(trigger_id)

`invocationLogs`

const result = await flowra.triggers.invocationLogs({ limit: 20 });

result = flowra.triggers.invocation_logs(limit=20)

`replayWebhook`

const result = await flowra.triggers.replayWebhook(logId);

result = flowra.triggers.replay_webhook(log_id)

`chat`

`createThread`

const result = await flowra.chat.createThread({ metadata: { ticketId: 'T-1' } });

result = flowra.chat.create_thread({'metadata': {'ticketId': 'T-1'}})

`getThread`

const result = await flowra.chat.getThread(threadId);

result = flowra.chat.get_thread(thread_id)

`updateThread`

const result = await flowra.chat.updateThread(threadId, { metadata: { title: 'Support' } });

result = flowra.chat.update_thread(thread_id, {'metadata': {'title': 'Support'}})

`deleteThread`

const result = await flowra.chat.deleteThread(threadId);

result = flowra.chat.delete_thread(thread_id)

`searchThreads`

const result = await flowra.chat.searchThreads({ /* SearchThreadsDto */ });

result = flowra.chat.search_threads({...})

`history`

const result = await flowra.chat.history(threadId, {});

result = flowra.chat.history(thread_id, {})

`state`

const result = await flowra.chat.state(threadId);

result = flowra.chat.state(thread_id)

`stream`

const result = await flowra.chat.stream(threadId, { input: { messages: [{ role: 'user', content: 'Hi' }] } });

result = flowra.chat.stream(thread_id, {'input': {'messages': [{'role': 'user', 'content': 'Hi'}]}}, as_events=True)

`listRuns`

const result = await flowra.chat.listRuns(threadId);

result = flowra.chat.list_runs(thread_id)

`cancelRun`

const result = await flowra.chat.cancelRun(threadId, runId);

result = flowra.chat.cancel_run(thread_id, run_id)

`generateTitle`

const result = await flowra.chat.generateTitle(threadId);

result = flowra.chat.generate_title(thread_id)

`sendOperatorReply`

const result = await flowra.chat.sendOperatorReply(threadId, { /* body */ });

result = flowra.chat.send_operator_reply(thread_id, {...})

`setReplyMode`

const result = await flowra.chat.setReplyMode(threadId, { /* body */ });

result = flowra.chat.set_reply_mode(thread_id, {...})

`joinStream`

const result = await flowra.chat.joinStream(threadId, runId);

result = flowra.chat.join_stream(thread_id, run_id, as_events=True)

`files`

`list`

const result = await flowra.files.list({ limit: 20 });

result = flowra.files.list(limit=20)

`upload`

TS: multipart body for generated client; PY: path, bytes, or file object.

const result = await flowra.files.upload('document', formDataBody as never);

result = flowra.files.upload('document', '/path/to/file.pdf')

`remove`

const result = await flowra.files.remove(fileId);

result = flowra.files.remove(file_id)

`download`

Returns file bytes / content.

const result = await flowra.files.download(fileId);

result = flowra.files.download(file_id)

`storageBreakdown`

const result = await flowra.files.storageBreakdown();

result = flowra.files.storage_breakdown()

`serveByFilename`

const result = await flowra.files.serveByFilename(filename);

result = flowra.files.serve_by_filename(filename)

`deleteMany`

const result = await flowra.files.deleteMany({ /* body */ });

result = flowra.files.delete_many({...})

`fileType`

const result = await flowra.files.fileType(fileType);

result = flowra.files.file_type(file_type)

`fileTypes`

const result = await flowra.files.fileTypes();

result = flowra.files.file_types()

`pruneOldest`

const result = await flowra.files.pruneOldest({ /* body */ });

result = flowra.files.prune_oldest({...})

`knowledge`

`list`

const result = await flowra.knowledge.list();

result = flowra.knowledge.list()

`create`

const result = await flowra.knowledge.create({ name: 'Help center' });

result = flowra.knowledge.create({'name': 'Help center'})

`get`

const result = await flowra.knowledge.get(collectionId);

result = flowra.knowledge.get(collection_id)

`rename`

const result = await flowra.knowledge.rename(collectionId, { name: 'Support FAQ' });

result = flowra.knowledge.rename(collection_id, {'name': 'Support FAQ'})

`remove`

const result = await flowra.knowledge.remove(collectionId);

result = flowra.knowledge.remove(collection_id)

`chunks`

const result = await flowra.knowledge.chunks(collectionId, { limit: 20 });

result = flowra.knowledge.chunks(collection_id, limit=20)

`sources`

const result = await flowra.knowledge.sources(collectionId);

result = flowra.knowledge.sources(collection_id)

`deleteSource`

const result = await flowra.knowledge.deleteSource(collectionId, { /* body */ });

result = flowra.knowledge.delete_source(collection_id, {...})

`ingestFile`

const result = await flowra.knowledge.ingestFile(collectionId, { /* body */ });

result = flowra.knowledge.ingest_file(collection_id, {...})

`ingestText`

const result = await flowra.knowledge.ingestText(collectionId, { /* body */ });

result = flowra.knowledge.ingest_text(collection_id, {...})

`ingestUrl`

const result = await flowra.knowledge.ingestUrl(collectionId, { url: 'https://docs.yoursite.com/faq' });

result = flowra.knowledge.ingest_url(collection_id, {'url': 'https://docs.yoursite.com/faq'})

`search`

const result = await flowra.knowledge.search(collectionId, { query: 'refund policy' });

result = flowra.knowledge.search(collection_id, {'query': 'refund policy'})

`setExposeViaMcp`

const result = await flowra.knowledge.setExposeViaMcp(collectionId, { /* body */ });

result = flowra.knowledge.set_expose_via_mcp(collection_id, {...})

`database`

`list`

const result = await flowra.database.list();

result = flowra.database.list()

`get`

const result = await flowra.database.get(collectionId);

result = flowra.database.get(collection_id)

`remove`

const result = await flowra.database.remove(collectionId);

result = flowra.database.remove(collection_id)

`documents`

const result = await flowra.database.documents(collectionId, { limit: 50 });

result = flowra.database.documents(collection_id, limit=50)

`createDocument`

const result = await flowra.database.createDocument(collectionId, { /* fields */ });

result = flowra.database.create_document(collection_id, {...})

`updateDocument`

const result = await flowra.database.updateDocument(collectionId, documentId, { /* fields */ });

result = flowra.database.update_document(collection_id, document_id, {...})

`deleteDocument`

const result = await flowra.database.deleteDocument(collectionId, documentId);

result = flowra.database.delete_document(collection_id, document_id)

`setExposeViaMcp`

const result = await flowra.database.setExposeViaMcp(collectionId, { /* body */ });

result = flowra.database.set_expose_via_mcp(collection_id, {...})

`sandbox`

`runEphemeral`

const result = await flowra.sandbox.runEphemeral({ language: 'javascript', source: 'return 1 + 1;' });

result = flowra.sandbox.run_ephemeral({'language': 'javascript', 'source': 'return 1 + 1;'})

`createSession`

const result = await flowra.sandbox.createSession({});

result = flowra.sandbox.create_session({})

`getSession`

const result = await flowra.sandbox.getSession(sessionId);

result = flowra.sandbox.get_session(session_id)

`execute`

const result = await flowra.sandbox.execute(sessionId, { language: 'python', source: 'print(2)' });

result = flowra.sandbox.execute(session_id, {'language': 'python', 'source': 'print(2)'})

`releaseSession`

const result = await flowra.sandbox.releaseSession(sessionId);

result = flowra.sandbox.release_session(session_id)

`startThreadComputer`

const result = await flowra.sandbox.startThreadComputer(threadId);

result = flowra.sandbox.start_thread_computer(thread_id)

`getThreadComputer`

const result = await flowra.sandbox.getThreadComputer(threadId);

result = flowra.sandbox.get_thread_computer(thread_id)

`releaseThreadComputer`

const result = await flowra.sandbox.releaseThreadComputer(threadId);

result = flowra.sandbox.release_thread_computer(thread_id)

`mcp`

`list`

const result = await flowra.mcp.list();

result = flowra.mcp.list()

`get`

const result = await flowra.mcp.get(serverId);

result = flowra.mcp.get(server_id)

`create`

const result = await flowra.mcp.create({ /* CreateMcpServerDto */ });

result = flowra.mcp.create({...})

`update`

const result = await flowra.mcp.update(serverId, { /* patch */ });

result = flowra.mcp.update(server_id, {...})

`remove`

const result = await flowra.mcp.remove(serverId);

result = flowra.mcp.remove(server_id)

`config`

const result = await flowra.mcp.config(serverId);

result = flowra.mcp.config(server_id)

`setAuthConfig`

const result = await flowra.mcp.setAuthConfig(serverId, { toolkitSlug: 'gmail', authConfigId });

result = flowra.mcp.set_auth_config(server_id, {'toolkitSlug': 'gmail', 'authConfigId': auth_config_id})

`clearAuthConfig`

const result = await flowra.mcp.clearAuthConfig(serverId, { toolkitSlug: 'gmail' });

result = flowra.mcp.clear_auth_config(server_id, {'toolkitSlug': 'gmail'})

`hostedSse`

const result = await flowra.mcp.hostedSse();

result = flowra.mcp.hosted_sse()

`hostedPost`

const result = await flowra.mcp.hostedPost({ /* MCP JSON-RPC body */ });

result = flowra.mcp.hosted_post({...})

`handleSse`

const result = await flowra.mcp.handleSse(serverId);

result = flowra.mcp.handle_sse(server_id)

`handlePost`

const result = await flowra.mcp.handlePost(serverId, { /* MCP JSON-RPC body */ });

result = flowra.mcp.handle_post(server_id, {...})

`llm`

`models`

const result = await flowra.llm.models();

result = flowra.llm.models()

`chat`

const result = await flowra.llm.chat({ messages: [{ role: 'user', content: 'Hello' }] });

result = flowra.llm.chat({'messages': [{'role': 'user', 'content': 'Hello'}]})

`generate`

const result = await flowra.llm.generate({ /* GenerateDto */ });

result = flowra.llm.generate({...})

`browser`

`status`

const result = await flowra.browser.status(sessionId);

result = flowra.browser.status(session_id)

`touch`

const result = await flowra.browser.touch(sessionId);

result = flowra.browser.touch(session_id)

`close`

const result = await flowra.browser.close(sessionId);

result = flowra.browser.close(session_id)

`view`

const result = await flowra.browser.view(sessionId, { /* query */ });

result = flowra.browser.view(session_id)

`completeConnection`

const result = await flowra.browser.completeConnection(sessionId);

result = flowra.browser.complete_connection(session_id)

`usage`

`list`

const result = await flowra.usage.list({ threadId });

result = flowra.usage.list(threadId=thread_id)

`balance`

const result = await flowra.usage.balance();

result = flowra.usage.balance()

`forExecution`

const result = await flowra.usage.forExecution(executionId);

result = flowra.usage.for_execution(execution_id)

​Root

​getProfile / get_profile

​asUser / as_user

​flowra.raw (example)

​tools

​list

​get

​create

​update

​remove

​setActive

​execute

​executionLogs

​toolkits

​list

​listWithTools

​get

​create

​update

​remove

​setActive

​messagingChannels

​listCategories

​skills

​list

​get

​create

​update

​remove

​addToLibrary

​catalogBrowse

​importGithub

​registryInstall

​registryList

​registrySearch

​workflows

​list

​get

​create

​update

​remove

​setActive

​run

​status

​resume

​executions

​execution

​statistics

​executionsFor

​addConnection

​changeConnection

​setAuthConfig

​clearAuthConfig

​clearConnection

​connections

​list

​listGrouped

​create

​createLink

​update

​remove

​authConfigs / auth_configs

​list

​get

​create

​remove

​users

​list

​create

​getByUsername

​toggleActive

​refreshAvatar

​triggers

​list

​upsert

​remove

​setStatus

​invocationLogs

​replayWebhook

​chat

Root

`getProfile` / `get_profile`

`asUser` / `as_user`

`flowra.raw` (example)

`tools`

`list`

`get`

`create`

`update`

`remove`

`setActive`

`execute`

`executionLogs`

`toolkits`

`list`

`listWithTools`

`get`

`create`

`update`

`remove`

`setActive`

`messagingChannels`

`listCategories`

`skills`

`list`

`get`

`create`

`update`

`remove`

`addToLibrary`

`catalogBrowse`

`importGithub`

`registryInstall`

`registryList`

`registrySearch`

`workflows`

`list`

`get`

`create`

`update`

`remove`

`setActive`

`run`

`status`

`resume`

`executions`

`execution`

`statistics`

`executionsFor`

`addConnection`

`changeConnection`

`setAuthConfig`

`clearAuthConfig`

`clearConnection`

`connections`

`list`

`listGrouped`

`create`

`createLink`

`update`

`remove`

`authConfigs` / `auth_configs`

`list`

`get`

`create`

`remove`

`users`

`list`

`create`

`getByUsername`

`toggleActive`

`refreshAvatar`

`triggers`

`list`

`upsert`

`remove`

`setStatus`

`invocationLogs`

`replayWebhook`

`chat`