SDK Reference

Every task receives a qbash object injected at runtime. No imports needed — it's just there.

# The full SDK is available as `qbash` inside any task script
result = qbash.ai.raw("Summarize this")
qbash.create_chat("Summary ready", result)

Generated live from the task SDK metadata. Browse the index below — or use the outline on the right — to jump to any method. Each one shows a ready-to-copy example, its parameters, and what it returns.

---

qbash

Top-level helpers called directly on the qbash object.

qbash.parallel(fn, items, concurrency=5, max_per_minute=None, continue_on_error=False, checkpoint=None, checkpoint_key=None, store_result=False, retry=None)→ParallelResult

Run fn(item) for each item using a producer-consumer pool.

Example

result = qbash.parallel(
    fn=process,
    items=items,
)

Parameter	Type	Required	Default	Description
fn	Callable	yes	—
items	Iterable	yes	—
concurrency	int	no	5
max_per_minute	Optional[int]	no	None
continue_on_error	bool	no	False
checkpoint	Optional[str]	no	None
checkpoint_key	Any	no	None
store_result	bool	no	False
retry	Union[int, bool, RetryPolicy, None]	no	None

retry: optional retry policy applied to fn(item) calls. retry=3 → up to 3 attempts (2 retries) on transient failures retry=1, retry=0, or retry=<negative int> → single call, no retry retry=False or None → no retry (single call) retry=True → default policy (3 attempts) retry=RetryPolicy(...) → full control Atomicity precondition: fn(item) may be called more than once if retry is enabled OR if checkpoint resume kicks in across runs. Each call's observable side effects MUST be atomic — wrap DB writes in `with db: ...`, or use idempotent statements (INSERT ... ON CONFLICT, MERGE). The SDK does NOT roll back partial state from a failed call. Returns ParallelResult(completed, skipped, errors, results). Results are in input order.

qbash.create_chat(title, content, skip_if_empty=False, files=None, read_only=True, model=None, project_id=None, user_id=None, user_email=None, shared_with=None, share_with_org=None, memory_folder_ids=None, system_message=None)→dict | None

Create a chat output message for this task run.

Example

result = qbash.create_chat(
    title="…",
    content={"key": "value"},
)

Parameter	Type	Required	Default	Description
title	str	yes	—	Chat thread name.
content	str | dict | list	yes	—	Assistant message body (str, or dict/list which will be JSON-stringified).
skip_if_empty	bool	no	False	If True and content is falsy, returns None without creating the chat.
files	list | None	no	None	Optional list of qbash file-reference objects (from qbash.files.write, qbash.inputs, etc.) to attach.
read_only	bool	no	True	When True (default), the user cannot reply -- the chat renders as a system notification. When False, the user can follow up; requires either model= or a project_id whose project has a default_llm_model.
model	str | None	no	None	LLM model id to use for the user's follow-up replies. Only meaningful when read_only=False. Required when read_only=False and project_id is not set. Must NOT be passed when project_id is set -- the project's default_llm_model is used so follow-ups behave like any other chat inside that project.
project_id	str | None	no	None	Optional project to associate the chat with. The chat owner must have access to this project. When set, the project's default_llm_model is used for follow-up replies and project tools (MCP, prompts, knowledge bases) are available.
user_id	str | None	no	None	Optional override for the chat owner. Must be a user in the same company as the task with an active membership.
user_email	str | None	no	None	Optional override for the chat owner by email address — convenient when an external caller knows the user by their account email rather than their qbash user ID. Same validation envelope as user_id (must resolve to a user in the same company with an active membership). If both user_id and user_email are passed, user_id wins.
shared_with	list | None	no	None	Optional list of additional org members to grant access to the new chat. Each entry is either an email string (defaults to read-only / "view") or a dict shaped like {"user_email": "...", "role": "view"} or {"user_id": "<uuid>", "role": "chat"}. Role aliases: "view" = read-only viewer, "chat" = full participant who can reply. Each recipient must be an active member of the task's company. All entries are validated up front — if any fails, no chat is created.
share_with_org	str | None	no	None	Optionally share the chat with EVERY active member of the task's company. "view" = whole org can read (read-only), "chat" = whole org can read and reply. None (default) = not shared org-wide. Unlike shared_with, this is a single org-level grant — membership is resolved live, so members added later automatically gain access and removed members lose it. Combine with shared_with to give specific people a different role than the org default.
memory_folder_ids	list[str] | None	no	None	Optional list of memory-folder UUIDs to expose as vector-search tools on follow-up replies (e.g. the folder the task summarized). Each folder must have AI search enabled and the chat owner must have a memory MCP connection for it. Ignored when read_only=True or project_id is set (a project already supplies its own memory and tool configuration).
system_message	str | None	no	None	Optional system message to seed follow-up replies with (sets the assistant's tone/role). Same precedence as memory_folder_ids -- ignored when read_only=True or project_id is set.

Chat ownership: by default the chat is owned by whoever pressed Run (qbash.run.user). For runs without a user (schedule, webhook, system triggers) the chat falls back to the task author (qbash.run.creator). Pass user_id= to override and force a specific owner; the user must belong to the same company as the task and have an active membership.

qbash.output(value, type=None)

Set the definitive return value for this task run.

Example

qbash.output(
    value="…",
)

Parameter	Type	Required	Default	Description
value	any	yes	—
type	str | None	no	None

Accepts any JSON-serializable value (None, bool, int, float, str, list, dict). The value is persisted on the AutomatedTaskExecution row, returned in the sync API entrypoint response body, and emitted as a `task_output` push_log event for the live feed. Project Pages: when this task is bound as the generator of a page (project home -> Pages -> New page), this value also produces the page's next edition after every successful run: * ``qbash.output(html_string, type="html")`` — the value must be a complete HTML document string; it is published verbatim as the page's next edition. You own the page's design. Scripts are stripped and a strict CSP is enforced (no external URLs; inline CSS/SVG and data: images only). * ``qbash.output(markdown_string, type="markdown")`` — rendered deterministically (no AI pass) into the qbash-branded page shell. Inline HTML blocks inside the markdown pass through, so you can mix prose with hand-built HTML charts. Same script/CSP rules. * ``qbash.output(anything_else)`` (no type) — dict, list, str — the platform renders it into a branded HTML page automatically with an AI pass. Content is never interpreted as HTML or markdown unless the type is passed explicitly. If a bound task never calls qbash.output, the page falls back to the run's output preview; runs with no usable output publish nothing. May only be called once per run; a second call raises RuntimeError. Thread-safe under qbash.parallel.run (workers share this namespace).

qbash.log(message)

Append a message to the task run log.

Example

qbash.log(
    message="…",
)

Parameter	Type	Required	Default	Description
message	str	yes	—

qbash.sleep(seconds)

Pause execution for the given number of seconds (max 900).

Example

qbash.sleep(
    seconds="…",
)

Parameter	Type	Required	Default	Description
seconds	any	yes	—

qbash.ai

AI tools — raw, run_prompt, and provider-native web/search tools.

qbash.ai.raw(instruction, files=None, system=None, model=None, temperature=None, max_tokens=None, output_schema=None, tools=None, cache=True, key=None)→str | dict

Call an LLM with the given instruction.

Example

result = qbash.ai.raw(
    instruction="…",
)

Parameter	Type	Required	Default	Description
instruction	str	yes	—	The user-facing instruction for the model.
files	list | None	no	None	Optional list of qbash file-reference objects to attach.
system	str | None	no	None	Optional system message. Defaults to a generic helpful-assistant prompt.
model	str | None	no	None	Optional model slug (e.g. "claude-haiku-4-5"). Falls back to the company's default model if omitted or invalid.
temperature	float | None	no	None	Optional sampling temperature (0.0-2.0).
max_tokens	int | None	no	None	Optional cap on response tokens.
output_schema	dict | None	no	None	Optional JSON Schema dict. When present, the model is constrained to produce JSON matching the schema and this method returns a dict instead of a string.
tools	list[dict] | None	no	None	Optional list of native tool providers to attach. Each entry is a dict with: - provider (required, str): integration slug (e.g. "opensearch") - credential (optional, str): credential name or UUID; omit to use the task's default credential for that provider - allowed_tools (optional, list[str]): tool name filter; omit or pass [] for all tools from that provider
cache	bool	no	True	Enable prompt caching (default True). Caches the system prompt and tool definitions so repeated calls pay ~10% input cost on cache hits (Anthropic). Other providers cache automatically. Pass False for a single LLM call in an infrequently-run task.
key	str | None	no	None

Returns: The model's text response as a string, or a dict if output_schema was provided.

qbash.ai.run_prompt(prompt_ref=None, variables=None, files=None, slug=None, cache=True)→str

Run a saved prompt by UUID or slug.

Example

result = qbash.ai.run_prompt(
    prompt_ref="…",
    variables={"key": "value"},
)

Parameter	Type	Required	Default	Description
prompt_ref	str | None	no	None	UUID or slug identifying the prompt.
variables	dict | None	no	None	Template variables as a dict.
files	list | None	no	None	Optional list of qbash file-reference objects to attach.
slug	str | None	no	None	Alternative keyword form for slug (same as passing a slug as prompt_ref).
cache	bool	no	True	Enable prompt caching (default True). See ai.raw() for details.

Returns: The rendered output (string, or a dict when the prompt has a structured_output schema).

qbash.ai.anthropic_web_search(query)→list

Search the web using Anthropic's built-in search tool.

Example

result = qbash.ai.anthropic_web_search(
    query="search terms",
)

Parameter	Type	Required	Default	Description
query	str	yes	—

qbash.ai.anthropic_web_fetch(url)→str

Fetch and extract the text content of a URL using Anthropic.

Example

result = qbash.ai.anthropic_web_fetch(
    url="https://…",
)

Parameter	Type	Required	Default	Description
url	str	yes	—

qbash.ai.openai_web_search(query)→list

Search the web using OpenAI's built-in search tool.

Example

result = qbash.ai.openai_web_search(
    query="search terms",
)

Parameter	Type	Required	Default	Description
query	str	yes	—

qbash.ai.gemini_google_search(query)→list

Search Google using Gemini's grounding tool.

Example

result = qbash.ai.gemini_google_search(
    query="search terms",
)

Parameter	Type	Required	Default	Description
query	str	yes	—

qbash.ai.gemini_url_context(urls)→str

Fetch and summarise one or more URLs using Gemini URL context.

Example

result = qbash.ai.gemini_url_context(
    urls=[...],
)

Parameter	Type	Required	Default	Description
urls	list | str	yes	—

qbash.ai.xai_x_search(query)→list

Search X (Twitter) using xAI's live search tool.

Example

result = qbash.ai.xai_x_search(
    query="search terms",
)

Parameter	Type	Required	Default	Description
query	str	yes	—

qbash.chats

Chat history search — search, read, and search within threads.

qbash.chats.search(query='', project_id=None, task_id=None, prompt_id=None, after=None, before=None, limit=10, offset=0)→dict

Search the executing user's chat threads.

Example

result = qbash.chats.search(
    query="search terms",
    project_id="…",
)

Parameter	Type	Required	Default	Description
query	str	no	''	Search term (matches thread names and message content). Can be empty to browse with filters only.
project_id	str | None	no	None	Filter to threads within a specific project (UUID).
task_id	str | None	no	None	Filter to threads that ran a specific automated task (UUID).
prompt_id	str | None	no	None	Filter to threads that used a specific prompt (UUID).
after	str | None	no	None	ISO 8601 datetime — only return threads created after this.
before	str | None	no	None	ISO 8601 datetime — only return threads created before this.
limit	int	no	10	Max results (default 10, max 25).
offset	int	no	0	Number of results to skip (default 0). Use with limit for pagination when has_more is true.

Full-text search across thread names and message content. Supports optional filters that can be combined freely — including with an empty query to browse by filters alone. Returns: dict with keys: threads (list), count, total, offset, has_more. Each thread has: id, name, project_id, project_name, updated_at, inserted_at, and optionally task_id.

qbash.chats.read(thread_id, limit=50, offset=0)→dict

Read messages from a specific chat thread.

Example

result = qbash.chats.read(
    thread_id="…",
)

Parameter	Type	Required	Default	Description
thread_id	str	yes	—	The chat thread UUID (from search results).
limit	int	no	50	Max messages to return (default 50, max 100).
offset	int	no	0	Number of messages to skip from the start (default 0). Use for pagination — e.g. offset=50, limit=50 for page 2.

Returns messages in chronological order with pagination support. Only works for threads owned by the executing user. Returns: dict with keys: thread_id, thread_name, project_id, total_messages, offset, limit, returned, has_more, messages. Each message has: id, role, content, model, sent_at.

qbash.chats.search_in_thread(thread_id, query, limit=10)→dict

Search for specific content within a single chat thread.

Example

result = qbash.chats.search_in_thread(
    thread_id="…",
    query="search terms",
)

Parameter	Type	Required	Default	Description
thread_id	str	yes	—	The chat thread UUID.
query	str	yes	—	Search term to find within the conversation.
limit	int	no	10	Max matching messages to return (default 10, max 30).

More efficient than paginating through a long conversation when looking for specific messages. Only works for threads owned by the executing user. Returns: dict with keys: thread_id, thread_name, query, matches, messages. Each message has: id, role, content, model, sent_at.

qbash.tasks

Call another task that this task has explicitly linked as a tool.

qbash.tasks.run(id_or_slug, inputs=None)→any

Run a linked task and return its result.

Example

result = qbash.tasks.run(
    id_or_slug="my-prompt",
)

Parameter	Type	Required	Default	Description
id_or_slug	str	yes	—	The linked task's UUID, or its exact name (tasks don't have a dedicated slug field — name is matched exactly and only among tasks this task has linked).
inputs	dict | None	no	None	Input values for the sub-task, matching its declared input schema. Values are coerced to their declared types (e.g. a numeric input still works if you pass a string).

Returns: For a fast (Lambda-class) sub-task: its output value — whatever the sub-task's ``qbash.output(...)`` call produced, unwrapped (a dict, list, string, number, bool, or None). For a long-running (Fargate-class) sub-task: a status dict ``{"status": "started" | "queued", "execution_id": str, "task_name": str, "message": str}`` instead of a result — a long-running task can't return synchronously. There is currently no SDK method to poll or await that execution from a script; treat it as fire-and-forget and check the task's run history in the UI if you need the outcome. Raises: ValueError: if id_or_slug is missing, or inputs is not a dict. SDK error: if the task isn't linked, isn't accessible, is an agent-runtime task, or the run itself fails (missing required inputs, credential errors, script errors, etc.).

qbash.documents

Document chunking — extraction_plan, extract_unit, split, contextualize_chunk.

qbash.documents.extraction_plan(file, strategy='hybrid_router')→dict

Split a document into per-page extraction units.

Example

result = qbash.documents.extraction_plan(
    file="…",
)

Parameter	Type	Required	Default	Description
file	any	yes	—	The source document — a qbash file-reference object or bare file_upload_id. PDF, Office, and plain-text formats.
strategy	str	no	'hybrid_router'	How to get text out of each page. ``"hybrid_router"`` (default) keeps a clean native text layer and falls back to the LLM per page; ``"llm_per_page"`` always uses the LLM; ``"native_text"`` always uses the native layer.

Converts the file to PDF if needed, splits it into one file per page, and reads each page's native text layer. Pages whose text layer is already clean come back with ``content`` pre-filled and cost nothing further; pages that need an LLM come back with ``content: None`` — pass those to :meth:`extract_unit`. Not idempotent: it calls the conversion service and creates a file record per page, so a re-run duplicates them. Checkpoint the result. Returns: dict with keys: units, unit_count, needs_llm. Each unit is {seq, page, content} — ``page`` is a file blob for :meth:`extract_unit` and ``content`` is the extracted text, or None when the page still needs an LLM pass. ``needs_llm`` is how many units have ``content: None``.

qbash.documents.extract_unit(page)→dict

Extract one page's text with an LLM.

Example

result = qbash.documents.extract_unit(
    page="…",
)

Parameter	Type	Required	Default	Description
page	any	yes	—	The page file reference from a plan unit's ``page`` field.

One LLM call — a natural ``qbash.parallel`` unit. Only worth calling for units :meth:`extraction_plan` returned with ``content: None``. Returns: dict with key: text.

qbash.documents.split(text=None, ref=None, doc_type='text')→dict

Split text into chunks and group them into contextualization windows.

Example

result = qbash.documents.split(
    text="…",
    ref="…",
)

Parameter	Type	Required	Default	Description
text	str | None	no	None	The document text to split. Exactly one of ``text`` or ``ref`` is required.
ref	any	no	None	A file reference to read the text from instead of passing it inline. Exactly one of ``text`` or ``ref`` is required.
doc_type	str	no	'text'	``"text"`` (default) splits on paragraph and heading boundaries; ``"csv"`` converts to a markdown table, keeps rows intact, and repeats the header block in every chunk.

Deterministic and cheap — re-run it instead of checkpointing it. The chunks are persisted as an artifact and the response carries only a handle to it: **no chunk text and no window text come back**. Pass ``chunks_ref`` plus a chunk's ``seq`` to :meth:`contextualize_chunk` and the server resolves that chunk's window itself. Chunk size and window size are platform settings, tuned server-side and not exposed here. Returns: dict with keys: chunks_ref, chunks, chunk_count, window_count. ``chunks`` is [{seq, window}] — sequence numbers and window indexes only, no text. Raises: ValueError: neither ``text`` nor ``ref`` supplied, or both.

qbash.documents.contextualize_chunk(chunks_ref, seq)→dict

Prepend window context to one chunk with an LLM.

Example

result = qbash.documents.contextualize_chunk(
    chunks_ref="…",
    seq=0,
)

Parameter	Type	Required	Default	Description
chunks_ref	any	yes	—	The ``chunks_ref`` handle from :meth:`split`.
seq	int	yes	—	Which chunk to contextualize — a ``seq`` from ``split``'s ``chunks`` list.

One LLM call — a natural ``qbash.parallel`` unit. The window text is never sent over the wire: the server loads the chunks artifact and rebuilds the window this ``seq`` belongs to. **Warm each window's cache before fanning out over it.** The window is prompt-cached, but the cache entry only becomes readable once a first response starts streaming, and it expires 5 minutes later. So per window: call this once, sequentially, for that window's first chunk, and only then ``qbash.parallel`` over the rest of that window. Warming every window up front instead means the early windows expire before the fan-out reaches them and every call pays full price. Returns: dict with keys: seq, text, cached. ``text`` is the generated context followed by the chunk itself. ``cached`` is whether this call read the window from the prompt cache.

qbash.memories

Memory operations — search, store, get, update, query, list, propositions.

qbash.memories.search(query, limit=5, folder=None, folder_id=None)→list

Keyword search over memory records. Returns a list of matching records.

Example

result = qbash.memories.search(
    query="search terms",
)

Parameter	Type	Required	Default	Description
query	str	yes	—
limit	int	no	5
folder	str | None	no	None
folder_id	str | None	no	None

qbash.memories.get(name, folder=None, folder_id=None)→dict

Fetch a single memory record by name.

Example

result = qbash.memories.get(
    name="…",
)

Parameter	Type	Required	Default	Description
name	str	yes	—
folder	str | None	no	None
folder_id	str | None	no	None

qbash.memories.store(name, content=None, metadata=None, file=None, await_embedding=False, embedding_timeout=None, folder=None, folder_id=None)→dict

Create a memory record.

Example

result = qbash.memories.store(
    name="…",
)

Parameter	Type	Required	Default	Description
name	str	yes	—
content	str | None	no	None
metadata	dict | None	no	None
file	dict | None	no	None
await_embedding	bool	no	False
embedding_timeout	int | None	no	None
folder	str | None	no	None
folder_id	str | None	no	None

Exactly one of ``content`` or ``file`` must be provided. - content: inline text (the doc's ``content`` field is set directly). - file: a qbash file-reference object (as returned by ``qbash.files.write`` or a Drive ``download_files`` call). The memories pipeline extracts text from the file and stores it as content. When ``await_embedding=True``, blocks until the doc's embedding is generated (or fails), polling every 15s. ``embedding_timeout`` seconds caps the wait; ``None`` polls indefinitely (Lambda runtime is the cap). Raises :class:`EmbeddingFailedError` if the doc reaches a terminal failed state; raises :class:`TimeoutError` if the timeout elapses without reaching a terminal status.

qbash.memories.archive(memory_id, folder=None, folder_id=None)→dict

Mark a memory as archived. Idempotent — archiving an

Example

result = qbash.memories.archive(
    memory_id="…",
)

Parameter	Type	Required	Default	Description
memory_id	str	yes	—
folder	str | None	no	None
folder_id	str | None	no	None

already-archived memory is a no-op success. Archived memories are excluded by default from vector_search, find_memory, query_memories, list_records, and get_propositions on the agent-facing MCP path.

qbash.memories.unarchive(memory_id, folder=None, folder_id=None)→dict

Restore an archived memory to active status. Idempotent.

Example

result = qbash.memories.unarchive(
    memory_id="…",
)

Parameter	Type	Required	Default	Description
memory_id	str	yes	—
folder	str | None	no	None
folder_id	str | None	no	None

Embeddings are preserved across archive/unarchive — restored memories are immediately searchable again.

qbash.memories.await_embedding(memory_id, timeout=None, folder=None, folder_id=None)→dict

Block until the memory's embeddings finish (or fail).

Example

result = qbash.memories.await_embedding(
    memory_id="…",
)

Parameter	Type	Required	Default	Description
memory_id	str	yes	—
timeout	int | None	no	None
folder	str | None	no	None
folder_id	str | None	no	None

Polls every 15 seconds — background-task cadence, no need for tight polling. Returns the doc's status fields when ``embedding_status`` reaches ``"completed"``. Raises :class:`EmbeddingFailedError` when status is ``"failed"``. Treats ``None``/``"pending"``/``"processing"`` as "keep waiting". ``timeout=None`` polls indefinitely.

qbash.memories.vector_search(query, limit=5, threshold=0.3, folder=None, folder_id=None)→list

Semantic search returning [{id, name, content, similarity}].

Example

result = qbash.memories.vector_search(
    query="search terms",
)

Parameter	Type	Required	Default	Description
query	str	yes	—
limit	int	no	5
threshold	float	no	0.3
folder	str | None	no	None
folder_id	str | None	no	None

qbash.memories.update(memory_id, content, metadata=None, merge=True, folder=None, folder_id=None)→dict

Update an existing memory record by ID.

Example

result = qbash.memories.update(
    memory_id="…",
    content="…",
)

Parameter	Type	Required	Default	Description
memory_id	str	yes	—
content	str	yes	—
metadata	dict | None	no	None
merge	bool	no	True
folder	str | None	no	None
folder_id	str | None	no	None

qbash.memories.query(name=None, metadata=None, folder=None, folder_id=None)→list

Filter records by name or metadata key-value pairs.

Example

result = qbash.memories.query(
    name="…",
    metadata={"key": "value"},
)

Parameter	Type	Required	Default	Description
name	str | None	no	None
metadata	dict | None	no	None
folder	str | None	no	None
folder_id	str | None	no	None

qbash.memories.list_all(folder=None, folder_id=None)→list

List all memory records (lightweight: id, name, created_at).

Example

result = qbash.memories.list_all(
    folder="my-folder",
    folder_id="my-folder",
)

Parameter	Type	Required	Default	Description
folder	str | None	no	None
folder_id	str | None	no	None

qbash.memories.get_propositions(memory_id, folder=None, folder_id=None)→list

Get semantic proposition chunks for a record.

Example

result = qbash.memories.get_propositions(
    memory_id="…",
)

Parameter	Type	Required	Default	Description
memory_id	str	yes	—
folder	str | None	no	None
folder_id	str | None	no	None

qbash.http

HTTP tool — outbound requests proxied through Elixir for URL validation.

qbash.http.request(method, url, headers=None, body=None, auth=None)→dict

Make an HTTP request. Returns {status, headers, body}.

Example

result = qbash.http.request(
    method="…",
    url="https://…",
)

Parameter	Type	Required	Default	Description
method	str	yes	—
url	str	yes	—
headers	dict | None	no	None
body	dict | str | None	no	None
auth	dict | None	no	None

qbash.files

Files tool — write, read, metadata, split, and convert operations.

qbash.files.open(ref, mode='rt', encoding='utf-8', errors='strict')→any

Open a file as a streaming file-like object.

Example

result = qbash.files.open(
    ref="…",
)

Parameter	Type	Required	Default	Description
ref	any	yes	—
mode	any	no	'rt'
encoding	any	no	'utf-8'
errors	any	no	'strict'

mode='rb' yields a binary stream backed by a presigned S3 GET. mode='rt' yields a text stream (utf-8 decoded by default).

qbash.files.write(content, name, content_type='text/plain')→dict

Write content as a named file. Returns a qbash file-reference object.

Example

result = qbash.files.write(
    content="…",
    name="…",
)

Parameter	Type	Required	Default	Description
content	any	yes	—
name	str	yes	—
content_type	str	no	'text/plain'

content: str, bytes, or file-like object with .read() name: filename (e.g. "report.csv") content_type: MIME type (e.g. "text/csv", "application/pdf") Files ≤ 10 MB are embedded in the RPC. Larger files use a two-phase presigned S3 upload automatically. The returned blob can be passed to `qbash.ai.raw(files=[ref])` or `qbash.create_chat(files=[ref])`.

qbash.files.begin_upload(name, content_type='application/octet-stream', byte_size=None)→dict

Request a presigned S3 upload URL for a large file.

Example

result = qbash.files.begin_upload(
    name="…",
)

Parameter	Type	Required	Default	Description
name	str	yes	—
content_type	str	no	'application/octet-stream'
byte_size	int | None	no	None

Returns {"upload_url": str, "file_upload_id": str}. After uploading to the URL, call complete_upload(file_upload_id). Most callers should prefer write(), which routes to begin/complete automatically.

qbash.files.complete_upload(file_upload_id)→dict

Confirm a large file upload and get the qbash file-reference object.

Example

result = qbash.files.complete_upload(
    file_upload_id="…",
)

Parameter	Type	Required	Default	Description
file_upload_id	str	yes	—

Call this after a successful PUT to the upload_url from begin_upload().

qbash.files.read(ref, encoding='text')→any

Read a file's contents by reference.

Example

result = qbash.files.read(
    ref="…",
)

Parameter	Type	Required	Default	Description
ref	any	yes	—
encoding	str	no	'text'

encoding="text" -> str (UTF-8 decoded). Raises UnicodeDecodeError on invalid UTF-8; use "bytes" for binary files. encoding="bytes" -> bytes. encoding="base64" -> str (base64-encoded content). Raises ValueError if the file is larger than 10 MB. For larger files, use qbash.files.download_url(ref) and stream from S3 directly.

qbash.files.download_url(ref)→str

Return a presigned S3 URL for the file (8 hour expiry).

Example

result = qbash.files.download_url(
    ref="…",
)

Parameter	Type	Required	Default	Description
ref	any	yes	—

Useful for streaming large files (>10 MB) or passing a URL to another service. Blocks until the file's malware scan has cleared so the URL is immediately usable.

qbash.files.metadata(ref, include_url=False)→dict

Return file metadata. With include_url=True, also includes a

Example

result = qbash.files.metadata(
    ref="…",
)

Parameter	Type	Required	Default	Description
ref	any	yes	—
include_url	bool	no	False

presigned download_url and waits for the file's scan to clear. Returns {file_upload_id, filename, content_type, byte_size, scan_status, processing_status} when include_url=False (fast peek — does not block on scan). Returns the same fields plus download_url when include_url=True (blocks on scan completion so the URL is immediately usable).

qbash.files.split_pdf(ref)→list

Split a PDF into individual pages.

Example

result = qbash.files.split_pdf(
    ref="…",
)

Parameter	Type	Required	Default	Description
ref	any	yes	—

Returns a list of qbash file-reference objects, one per page. Each object can be passed directly to qbash.ai.raw(files=[page]).

qbash.files.convert(ref)→dict

Convert a file to a simpler format.

Example

result = qbash.files.convert(
    ref="…",
)

Parameter	Type	Required	Default	Description
ref	any	yes	—

Output format is determined by input type: .doc/.docx/.rtf/.odt -> txt; .xlsx/.ods -> csv; .pptx/.ppt/.odp -> pdf. Returns {file_upload_id, filename, content_type, download_url}. Note: to pass a converted file to qbash.ai.raw, use the ORIGINAL ref — the LLM automatically handles conversion for supported formats.

qbash.files.zip(entries)→any

Create a zip archive from a list of (filename, content_bytes) tuples.

Example

result = qbash.files.zip(
    entries="…",
)

Parameter	Type	Required	Default	Description
entries	any	yes	—

qbash.files.zip([("a.pptx", bytes1), ("b.csv", bytes2)]) -> bytes Filenames are sanitized (path components stripped). Duplicate names after sanitization get a _1, _2, etc. suffix.

qbash.files.writer(name, content_type='text/plain')→StreamingWriter

Open a streaming file writer for incremental writes.

Example

result = qbash.files.writer(
    name="…",
)

Parameter	Type	Required	Default	Description
name	str	yes	—
content_type	str	no	'text/plain'

Returns a StreamingWriter. Call .write(data) to append, .close() to finalize and get the qbash file-reference object.

qbash.files.download(url, filename, content_type=None, headers=None, auth=None, timeout=None)→dict

Download a file from a URL and upload it to S3 server-side.

Example

result = qbash.files.download(
    url="https://…",
    filename="…",
)

Parameter	Type	Required	Default	Description
url	str	yes	—	URL to download from (http or https).
filename	str	yes	—	Name for the stored file (e.g. "report.pdf").
content_type	str | None	no	None	Override content type. Auto-detected from the response Content-Type header if not provided.
headers	dict | None	no	None	Optional request headers dict.
auth	dict | None	no	None	Optional auth dict (same format as qbash.http.request).
timeout	int | None	no	None	Download timeout in milliseconds (default: 60000).

Returns a qbash file-reference object (same as qbash.files.write). The file is downloaded on the server — binary data never transits the RPC channel.

qbash.inputs

Inputs accessor — read-only view over merged trigger + user inputs.

qbash.inputs.get(name, default=None)→Any

Return the value for input param `name`, or `default` if absent.

Example

result = qbash.inputs.get(
    name="…",
)

Parameter	Type	Required	Default	Description
name	str	yes	—
default	Any	no	None

qbash.inputs.all()→dict

Return all input params as a dict.

Example

result = qbash.inputs.all()

qbash.checkpoint

qbash.checkpoint — run-scoped key/value store (DynamoDB-backed, no RPC).

qbash.checkpoint.done(key)→bool

Return True if this key has been marked or set.

Example

result = qbash.checkpoint.done(
    key="my-key",
)

Parameter	Type	Required	Default	Description
key	str	yes	—

qbash.checkpoint.mark(key)→any

Record completion with no stored value.

Example

result = qbash.checkpoint.mark(
    key="my-key",
)

Parameter	Type	Required	Default	Description
key	str	yes	—

qbash.checkpoint.get(key)→Optional[Any]

Return stored value, or None if absent or mark-only.

Example

result = qbash.checkpoint.get(
    key="my-key",
)

Parameter	Type	Required	Default	Description
key	str	yes	—

qbash.checkpoint.set(key, value)→any

Store a JSON-serializable value (also marks as done).

Example

result = qbash.checkpoint.set(
    key="my-key",
    value="…",
)

Parameter	Type	Required	Default	Description
key	str	yes	—
value	Any	yes	—

qbash.checkpoint.get_or_set(key, fn)→Any

Return cached value if present; otherwise call fn(), store, and return.

Example

result = qbash.checkpoint.get_or_set(
    key="my-key",
    fn=process,
)

Parameter	Type	Required	Default	Description
key	str	yes	—
fn	Callable	yes	—

Not appropriate when fn() can return None — use explicit get/set instead.

qbash.checkpoint.query_prefix(prefix)→dict[str, Any]

Return all key-value pairs where key starts with prefix.

Example

result = qbash.checkpoint.query_prefix(
    prefix="…",
)

Parameter	Type	Required	Default	Description
prefix	str	yes	—

Uses DynamoDB Query with begins_with on the sort key. All keys share the same partition key (exec:{scope}). Handles pagination for result sets exceeding 1 MB.

qbash.cache

qbash.cache — task-scoped key/value store with required TTL.

qbash.cache.get(key)→Optional[Any]

Return stored value if present and not expired, else None.

Example

result = qbash.cache.get(
    key="my-key",
)

Parameter	Type	Required	Default	Description
key	str	yes	—

qbash.cache.set(key, value, ttl)→any

Store value with TTL. ttl: int seconds or '1h'/'1d' string.

Example

result = qbash.cache.set(
    key="my-key",
    value="…",
    ttl="…",
)

Parameter	Type	Required	Default	Description
key	str	yes	—
value	Any	yes	—
ttl	any	yes	—

qbash.cache.get_or_set(key, fn, ttl)→Any

Return cached value if present; otherwise call fn(), store, and return.

Example

result = qbash.cache.get_or_set(
    key="my-key",
    fn=process,
    ttl="…",
)

Parameter	Type	Required	Default	Description
key	str	yes	—
fn	Callable	yes	—
ttl	any	yes	—

Not appropriate when fn() can return None — use explicit get/set instead.

qbash.cache.delete(key)→any

Explicitly evict a cached value.

Example

result = qbash.cache.delete(
    key="my-key",
)

Parameter	Type	Required	Default	Description
key	str	yes	—

qbash.run

qbash.run — runtime metadata for the current task invocation.

Properties

Property	Type	Description
qbash.run.execution_id	str	Unique id for this run; correlate against logs and execution records.
qbash.run.task_id	str | None	The AutomatedTask id this run belongs to; None for unsaved test runs.
qbash.run.is_test	bool	True when invoked as an unsaved draft from the task editor.
qbash.run.started_at	datetime	UTC timestamp of when this run was enqueued (tz-aware).
qbash.run.last_run_at	datetime | None	UTC timestamp of the previous successful run; None on first run.
qbash.run.user	dict | None	{"id": uuid} of the human who pressed Run; None for schedule/webhook/system.
qbash.run.creator	dict | None	{"id": uuid} of the task author; the authorization subject for credentials and memory.
qbash.run.company	dict | None	{"id": uuid} of the company this task runs under; None when unscoped.
qbash.run.project	dict | None	{"id": uuid} of the project bound to this task; None when standalone.

qbash.dates

qbash.dates — date and datetime utilities for task scripts.

qbash.dates.today()→date

Return today's UTC date.

Example

result = qbash.dates.today()

Use this instead of date.today(), which returns the lambda container's local date — undefined in practice.

qbash.dates.now()→datetime

Return the current UTC datetime (tz-aware).

Example

result = qbash.dates.now()

qbash.dates.parse(value)→datetime

Parse a value into a tz-aware UTC datetime.

Example

result = qbash.dates.parse(
    value="…",
)

Parameter	Type	Required	Default	Description
value	any	yes	—

Accepts: - datetime -> returned as-is if tz-aware; if naive, assumed UTC - date -> midnight UTC of that date - str -> parsed via dateutil; assumed UTC if no tz - None -> raises ValueError Raises: - ValueError if value is None, empty, or unparseable - TypeError if value is not str/date/datetime

qbash.powerpoint

PowerPoint utilities — exposed as qbash.powerpoint in user scripts.

qbash.powerpoint.fill(template_bytes, data)→bytes

Fill {{placeholders}} in a PPTX template.

Example

result = qbash.powerpoint.fill(
    template_bytes="…",
    data={"key": "value"},
)

Parameter	Type	Required	Default	Description
template_bytes	bytes	yes	—
data	dict	yes	—

qbash.powerpoint.fill(template_bytes, {"key": "val"}) -> bytes Read the template with qbash.files.read(ref, encoding="bytes") first. Keys must be word characters only (a-z, 0-9, underscore). Replacement text inherits the first run's formatting when a placeholder spans multiple XML runs.

qbash.parsers

qbash.parsers — format helpers for any file-like input.

qbash.parsers.csv_chunks(f, chunk_size=1000, has_header=True, dialect='excel')→Iterator[list[dict]]

Yield CSV rows in batches of `chunk_size` from a text file-like.

Example

result = qbash.parsers.csv_chunks(
    f="…",
)

Parameter	Type	Required	Default	Description
f	TextIO	yes	—
chunk_size	int	no	1000
has_header	bool	no	True
dialect	str	no	'excel'

With has_header=True the first row becomes the keys for every dict. With has_header=False keys are "col_0", "col_1", ... The file-like MUST be opened in text mode (mode='rt' on client.open(), or csv-friendly settings on a local open()). For binary inputs, wrap with io.TextIOWrapper first.

qbash.parsers.xlsx_chunks(f, chunk_size=1000, has_header=True, sheets=None)→Iterator[list[dict]]

Yield XLSX rows in batches of `chunk_size` from a binary file-like.

Example

result = qbash.parsers.xlsx_chunks(
    f="…",
)

Parameter	Type	Required	Default	Description
f	BinaryIO	yes	—
chunk_size	int	no	1000
has_header	bool	no	True
sheets	list[str | int] | None	no	None

f must be a binary file-like object (BytesIO). String paths and raw bytes are rejected — use BytesIO(sftp.read(path, mode='rb')).

qbash.parsers.line_chunks(f, chunk_size=1000)→Iterator[list[str]]

Yield lines in batches of `chunk_size` from a text file-like.

Example

result = qbash.parsers.line_chunks(
    f="…",
)

Parameter	Type	Required	Default	Description
f	TextIO	yes	—
chunk_size	int	no	1000

Lines retain their trailing newline (matches stdlib `for line in f:` shape). Strip with .rstrip('\n') in user code if undesired.

qbash.integrations

Connected services, called as qbash.integrations.<provider>.<method>(). Expand a provider to see its methods.

active_campaignActiveCampaign13 methods

active_campaign.list_campaigns(limit=None, offset=None, status=None, orders_sdate=None)List campaigns with their engagement stats (opens, clicks, bounces, unsubscribes).

active_campaign.get_campaign(campaign_id)Get a single campaign by ID with full engagement stats.

active_campaign.list_campaign_links(campaign_id)List the trackable links in a campaign (URL, name, ref, tracking flags).

active_campaign.get_campaign_revenue(campaign_id)Get aggregate revenue attributed to a campaign.

active_campaign.list_contacts(limit=None, offset=None, email=None, list_id=None, tag_id=None, status=None, search=None)List or search contacts with optional filters.

active_campaign.get_contact(contact_id)Get a single contact by ID with bounce + activity counters.

active_campaign.list_contact_activities(contact_id, after=None, limit=None, offset=None, include=None)List engagement activities for a contact (opens, clicks, automation events).

active_campaign.list_contact_tags(contact_id)List the contact-tag association records for a contact.

active_campaign.list_lists(limit=None, offset=None)List all lists in the account.

active_campaign.list_tags(limit=None, offset=None, search=None)List all tags in the account.

active_campaign.add_tag_to_contact(contact_id, tag_id)Apply a tag to a contact.

active_campaign.remove_tag_from_contact(contact_id, tag_id)Remove a tag from a contact. Looks up the contactTag association and deletes it.

active_campaign.track_event(event, eventdata=None, email=None)Send a custom event to ActiveCampaign site tracking. Uses event_key + actid credentials, not the API token.

affinityAffinity13 methods

affinity.search_persons(term=None, page_size=None, page_token=None, with_interaction_dates=False, with_opportunities=False, with_current_organizations=False)Search for persons in Affinity by name or email.

affinity.get_person(personId, with_interaction_dates=False, with_opportunities=False, with_current_organizations=False)Get detailed information for a specific Affinity person by ID.

affinity.search_organizations(term=None, exact_match=False, page_size=None, page_token=None, with_interaction_dates=False, with_interaction_persons=False)Search for organizations in Affinity by domain or name.

affinity.get_organization(organizationId, with_interaction_dates=False, with_interaction_persons=False)Get detailed information for a specific Affinity organization by ID.

affinity.get_field_values(organization_id=None, person_id=None, list_entry_id=None, opportunity_id=None)Get field values for an entity

affinity.get_list_entries(list_id, page_size=None, page_token=None)Get entries for a list

affinity.get_organization_list_entries(organization_id)Get all list entries for an organization

affinity.get_fields(list_id)Get field definitions for a list, including dropdown options

affinity.create_field_value(field_id, entity_id, value, list_entry_id=None)Create a field value on an entity

affinity.update_field_value(field_value_id, value)Update an existing field value

affinity.delete_field_value(field_value_id)Delete a field value

affinity.create_list_entry(list_id, entity_id)Add an entity to a list

affinity.delete_list_entry(list_entry_id, list_id)Remove an entity from a list

ahrefsAhrefs8 methods

ahrefs.domain_rating(target, date=None)Get Domain Rating and Ahrefs Rank for a domain.

ahrefs.site_metrics(target, date=None, country=None, target_mode=None)Get overall SEO metrics: traffic, keywords, backlinks.

ahrefs.backlinks(target, limit=100, offset=0, target_mode=None, order_by=None)List backlinks pointing to a domain.

ahrefs.referring_domains(target, limit=100, offset=0, order_by=None)Get referring domains with their metrics.

ahrefs.organic_keywords(target, country="us", limit=100, offset=0, order_by=None)Get organic keywords a domain ranks for.

ahrefs.top_pages(target, country="us", limit=100, offset=0)Get top pages by organic traffic.

ahrefs.organic_competitors(target, country="us", limit=100)Get organic competitors in SERPs.

ahrefs.keyword_overview(keywords, country="us")Get keyword metrics: volume, difficulty, CPC.

airtableAirtable16 methods

airtable.list_bases()List all accessible Airtable bases.

airtable.list_tables(base_id, detail_level="full")List tables in an Airtable base.

airtable.describe_table(base_id, tableId, detail_level="full")Get schema and metadata for a specific Airtable table.

airtable.list_records(base_id, tableId, filterByFormula=None, maxRecords=None, view=None, offset=None, pageSize=None)List records from an Airtable table. Returns up to 100 records per page. Use the returned offset to fetch subsequent pages.

airtable.search_records(base_id, tableId, searchTerm, fieldIds=None, maxRecords=None, offset=None, pageSize=None)Search records in an Airtable table by text. When fieldIds is omitted, automatically searches all text fields.

airtable.get_record(base_id, tableId, recordId)Get a specific Airtable record by ID.

airtable.create_record(base_id, tableId, fields)Create a new record in an Airtable table.

airtable.batch_create_records(base_id, tableId, records)Create up to 10 records in an Airtable table.

airtable.batch_update_records(base_id, tableId, records)Update up to 10 existing records in an Airtable table.

airtable.batch_delete_records(base_id, tableId, recordIds)Delete up to 10 records from an Airtable table by ID.

airtable.get_base_schema(base_id)Get the full schema for an Airtable base (all tables and fields).

airtable.list_field_types()Reference list of all Airtable field types organised by category.

airtable.get_table_views(base_id, tableId)List views configured on an Airtable table.

airtable.create_table(base_id, name, tableFields, description=None)Create a new table in an Airtable base.

airtable.create_field(base_id, tableId, fieldConfig)Create a new field in an existing Airtable table.

airtable.update_field(base_id, tableId, fieldId, updates)Update an existing field's name, description, or select options. Fields cannot be deleted via the Airtable API; rename or clear values instead.

algoliaAlgolia5 methods

algolia.list_indices(hits_per_page=100, page=0)List Algolia indices visible to the configured API key.

algolia.search_index(index_name, query=None, hits_per_page=20, page=0, filters=None, facet_filters=None, numeric_filters=None, attributes_to_retrieve=None, restrict_searchable_attributes=None, get_ranking_info=False, typo_tolerance=None)Search a single Algolia index and return matching hits.

algolia.multi_search(requests)Run multiple Algolia index searches in one request.

algolia.browse_index(index_name, query=None, cursor=None, hits_per_page=20, filters=None, attributes_to_retrieve=None)Browse records from an Algolia index with cursor pagination.

algolia.get_object(index_name, object_id, attributes_to_retrieve=None)Fetch one Algolia object by object ID.

apolloApollo.io8 methods

apollo.people_search(person_titles=None, person_seniorities=None, person_locations=None, q_keywords=None, q_organization_domains_list=None, organization_ids=None, organization_num_employees_ranges=None, page=1, per_page=25)Search Apollo's database for people. No credits consumed. Returns obfuscated previews — use person_enrich to reveal contact info.

apollo.person_enrich(first_name=None, last_name=None, name=None, email=None, hashed_email=None, organization_name=None, domain=None, id=None, linkedin_url=None, reveal_personal_emails=False, reveal_phone_number=False, webhook_url=None, run_waterfall_email=False, run_waterfall_phone=False)Enrich a single person. Consumes credits when a match is found. Pass any combination of identifiers (email, linkedin_url, name+domain).

apollo.bulk_person_enrich(people, reveal_personal_emails=False, reveal_phone_number=False, webhook_url=None, run_waterfall_email=False, run_waterfall_phone=False)Enrich up to 10 people in one call. Pass a list of person identifier maps (first_name/last_name/email/domain/linkedin_url).

apollo.org_enrich(domain=None, linkedin_url=None, name=None, website=None)Enrich a single organization. Provide at least one of domain / linkedin_url / name / website.

apollo.bulk_org_enrich(orgs)Enrich up to 10 organizations by domain.

apollo.org_jobs(organization_id, page=1, per_page=25)List active job postings for an Apollo organization. Strong signal for growth and AI-team building.

apollo.org_news(organization_ids, categories=None, published_at_min=None, published_at_max=None, page=1, per_page=25)Search Apollo's news index for events about given organizations (funding, hires, acquisitions, layoffs, etc.).

apollo.usage_stats()View per-endpoint Apollo API usage and rate-limit headroom. Requires a master API key.

asanaAsana20 methods

asana.list_workspaces()List all accessible Asana workspaces.

asana.list_users(workspace_gid, limit=50)List users in a workspace.

asana.list_projects(workspace_gid, limit=50)List projects in a workspace.

asana.get_project(project_gid)Get details of a specific project.

asana.list_sections(project_gid)List sections in a project.

asana.list_tasks(project_gid=None, section_gid=None, limit=50, completed_since=None, offset=None)List tasks in a project or section.

asana.list_subtasks(task_gid, limit=50)List subtasks of a task.

asana.get_task(task_gid)Get full details of a specific task.

asana.list_task_stories(task_gid, limit=50, offset=None)List comments and activity on a task.

asana.search_tasks(workspace_gid, text, limit=20, completed=None)Search tasks by keyword in a workspace.

asana.create_task(name, workspace_gid=None, project_gid=None, notes=None, due_on=None, assignee=None)Create a new task.

asana.create_subtask(task_gid, name, notes=None, due_on=None, assignee=None)Create a subtask under a parent task.

asana.update_task(task_gid, name=None, notes=None, due_on=None, assignee=None, completed=None)Update an existing task.

asana.move_task_to_section(task_gid, section_gid)Move a task into a section.

asana.set_task_dependencies(task_gid, dependency_gids)Set tasks that a task depends on.

asana.delete_task(task_gid)Delete a task.

asana.add_comment(task_gid, text)Add a comment to a task.

asana.bulk_create_tasks(tasks)Create multiple tasks at once. Returns results for each task.

asana.bulk_update_tasks(updates)Update multiple tasks at once. Returns results for each task.

asana.create_project(name, workspace_gid, team_gid=None, notes=None, color=None)Create a new project in a workspace.

awsAmazon Web Services1 method

aws.knowledge_base(knowledgeBaseId, queries, contentTypeFilters=None, slugs=None, awsRegion=None, resultsLength=10, fetchAllResults=False)Search an AWS Bedrock knowledge base with one or more queries.

basecampBasecamp30 methods

basecamp.list_accounts()List Basecamp accounts the user has access to.

basecamp.list_people(account_id, page=None)List people in the account.

basecamp.get_person(account_id, id)Get a person's profile by ID.

basecamp.list_projects(account_id, status=None, page=None)List projects in the account.

basecamp.get_project(account_id, id)Get a project by ID. Includes dock with tool IDs (todoset, message_board, chat, vault).

basecamp.create_project(account_id, name, description=None)Create a new project.

basecamp.update_project(account_id, id, name=None, description=None)Update a project. Basecamp replaces the full resource — include all fields you want to preserve.

basecamp.list_todolists(account_id, project_id, todoset_id, status=None, page=None)List to-do lists in a project's todoset. Requires todoset_id from get_project dock.

basecamp.get_todolist(account_id, project_id, id)Get a to-do list by ID.

basecamp.create_todolist(account_id, project_id, todoset_id, name, description=None)Create a to-do list in a project's todoset.

basecamp.list_todos(account_id, project_id, todolist_id, completed=None, page=None)List to-dos in a to-do list.

basecamp.get_todo(account_id, project_id, id)Get a to-do by ID.

basecamp.create_todo(account_id, project_id, todolist_id, content, description=None, assignee_ids=None, due_on=None, starts_on=None)Create a to-do in a to-do list.

basecamp.update_todo(account_id, project_id, id, content=None, description=None, assignee_ids=None, due_on=None, starts_on=None)Update a to-do. Basecamp replaces the full resource — include all fields you want to preserve.

basecamp.complete_todo(account_id, project_id, id)Mark a to-do as complete.

basecamp.uncomplete_todo(account_id, project_id, id)Mark a to-do as incomplete.

basecamp.list_messages(account_id, project_id, message_board_id, page=None)List messages on a project's message board. Requires message_board_id from get_project dock.

basecamp.get_message(account_id, project_id, id)Get a message by ID.

basecamp.create_message(account_id, project_id, message_board_id, subject, content=None, status=None)Post a message to a project's message board.

basecamp.update_message(account_id, project_id, id, subject=None, content=None, status=None)Update a message. Basecamp replaces the full resource — include all fields you want to preserve.

basecamp.list_comments(account_id, project_id, recording_id, page=None)List comments on a recording (message, to-do, document, etc.).

basecamp.get_comment(account_id, project_id, id)Get a comment by ID.

basecamp.create_comment(account_id, project_id, recording_id, content)Add a comment to a recording.

basecamp.update_comment(account_id, project_id, id, content)Update a comment. Basecamp replaces the full resource — include all fields you want to preserve.

basecamp.list_campfire_lines(account_id, project_id, chat_id, page=None)List lines (messages) in a project's campfire. Requires chat_id from get_project dock.

basecamp.create_campfire_line(account_id, project_id, chat_id, content, content_type=None)Post a line to a project's campfire chat.

basecamp.list_documents(account_id, project_id, vault_id, page=None)List documents in a project's vault. Requires vault_id from get_project dock.

basecamp.get_document(account_id, project_id, id)Get a document by ID.

basecamp.create_document(account_id, project_id, vault_id, title, content, status=None)Create a document in a project's vault.

basecamp.update_document(account_id, project_id, id, title=None, content=None, status=None)Update a document. Basecamp replaces the full resource — include all fields you want to preserve.

bugsnagBugsnag8 methods

bugsnag.list_organizations()List organizations for the authenticated user.

bugsnag.list_projects(organization_id)List projects for an organization.

bugsnag.list_errors(project_id, sort=None, direction=None, per_page=None)List errors for a project with optional sorting.

bugsnag.get_error(project_id, error_id)Get a single error by ID.

bugsnag.get_error_events(project_id, error_id, per_page=None)List events (occurrences) for an error.

bugsnag.get_event(project_id, event_id)Get a single event (error occurrence) by ID.

bugsnag.get_error_trend(project_id, error_id, buckets_count=None)Get error event count over time buckets.

bugsnag.get_project_stability(project_id)Get project stability trend data.

cobaltCobalt34 methods

cobalt.list_companies(sort=None, limit=None, offset=None)List all portfolio companies.

cobalt.get_company(company_uid)Get a company by identifier.

cobalt.create_company(name, currency=None)Create a company.

cobalt.update_company(company_uid, name=None, currency=None)Update a company.

cobalt.delete_company(company_uid)Delete a company.

cobalt.list_custom_fields()List all custom fields.

cobalt.get_custom_field(custom_field_uid)Get a custom field by identifier.

cobalt.create_custom_field(name, field_type, has_date, default_fund, default_company, default_deal, default_cashflow)Create a custom field.

cobalt.update_custom_field(custom_field_uid, name=None)Update a custom field.

cobalt.delete_custom_field(custom_field_uid)Delete a custom field.

cobalt.list_custom_field_values(entity_uids, custom_field_uids=None, as_of_date=None)List custom field values for entities.

cobalt.get_custom_field_value(uid)Get a custom field value by identifier.

cobalt.create_custom_field_value(custom_field_uid, value, company_uid=None, deal_uid=None, fund_uid=None, cashflow_uid=None)Create a custom field value.

cobalt.update_custom_field_value(uid, value=None, date=None)Update a single custom field value.

cobalt.update_custom_field_values_batch(custom_field_values)Batch update custom field values.

cobalt.delete_custom_field_value(uid)Delete a custom field value.

cobalt.list_deals(portfolio_uid=None, fund_uid=None, company_uid=None, sort=None, limit=None, offset=None)List deals with optional filters.

cobalt.get_deal(deal_uid)Get a deal by identifier.

cobalt.create_deal(company_uid, fund_uid, currency_symbol=None)Create a deal.

cobalt.update_deals(deals)Batch update deals.

cobalt.delete_deal(deal_uid)Delete a single deal.

cobalt.delete_deals_batch(deal_uids)Batch delete deals.

cobalt.list_funds(portfolio_uid=None, sort=None, limit=None, offset=None)List all funds.

cobalt.get_fund(fund_uid)Get a fund by identifier.

cobalt.create_fund(name, portfolio_uid=None, currency=None)Create a fund.

cobalt.update_fund(fund_uid, name=None)Update a fund.

cobalt.delete_fund(fund_uid)Delete a fund.

cobalt.list_portfolios(limit=None, offset=None)List all portfolios.

cobalt.get_portfolio(portfolio_uid)Get a portfolio by identifier.

cobalt.create_portfolio(name)Create a portfolio.

cobalt.update_portfolio(portfolio_uid, name=None)Update a portfolio.

cobalt.delete_portfolio(portfolio_uid)Delete a portfolio.

cobalt.list_currencies()List all currencies.

cobalt.check_status()Check Cobalt API status.

dataforseoDataForSEO4 methods

dataforseo.keyword_volume(keywords, location_code=2840, language_code="en", include_monthly_searches=False)Look up search volume, CPC, and competition for a known list of keywords.

dataforseo.keyword_ideas(keywords, location_code=2840, language_code="en", limit=100)Generate keyword ideas from seed keywords. Returns related keywords with volume and CPC.

dataforseo.keyword_suggestions(keyword, location_code=2840, language_code="en", limit=100, offset=0, include_seed_keyword=True)Long-tail keyword discovery from a single seed keyword. Returns suggestions with difficulty and volume.

dataforseo.related_keywords(keyword, location_code=2840, language_code="en", limit=100, offset=0, depth=1)Expand a seed keyword via Google's "searches related to" graph.

fathomFathom3 methods

fathom.list_meetings(cursor=None, recorded_by=None, created_after=None, created_before=None, teams=None, meeting_type=None, include_transcript=None, include_summary=None, include_action_items=None)List recent meetings with optional date range and recorder filters.

fathom.search_meetings(search_term, cursor=None, recorded_by=None, created_after=None, created_before=None, teams=None, meeting_type=None)Search meetings by title keyword with optional date and recorder filters.

fathom.get_transcript(recording_id)Get the full transcript for a specific recording.

firefliesFireflies.ai8 methods

fireflies.list_transcripts(limit=10, skip=0)Get a list of meeting transcripts.

fireflies.get_transcript(transcript_id)Get full transcript details and AI summary.

fireflies.search_transcripts(search_term, limit=100, skip=0)Search for transcripts by keywords.

fireflies.get_analytics(user_id=None, start_date=None, end_date=None)Retrieve conversation analytics.

fireflies.add_bot_to_meeting(meeting_url, title=None, attendee_email=None)Add Fireflies bot to a live meeting.

fireflies.update_meeting(transcript_id, title=None, channel_id=None, privacy=None)Update meeting metadata.

fireflies.delete_transcript(transcript_id)Permanently delete a transcript.

fireflies.ask_fred(question, transcript_ids=None, thread_id=None)Ask AI questions about transcripts.

githubGitHub13 methods

github.list_repos()List repositories accessible to the authenticated user.

github.list_pull_requests(owner, repo, state=None)List pull requests in a repository.

github.get_pull_request(owner, repo, pr_number)Get details of a specific pull request.

github.comment_on_pull_request(owner, repo, pr_number, body)Post a comment on a pull request.

github.list_pr_comments(owner, repo, pr_number)List comments on a pull request.

github.list_pr_files(owner, repo, pr_number)List files changed in a pull request.

github.get_file_contents(owner, repo, path, ref=None)Get the contents of a file in a repository.

github.list_commits(owner, repo, sha=None)List commits in a repository.

github.get_commit(owner, repo, sha)Get details of a specific commit, including files changed and patch.

github.compare_commits(owner, repo, base, head)Compare two commits, branches, or tags. Returns ahead/behind counts and changed files with patches.

github.search_code(query, sort=None, order=None, per_page=None)Search for code across repositories. Returns matching file paths and text fragments.

github.get_repo(owner, repo)Get repository metadata including default branch, description, visibility, and language.

github.get_issue(owner, repo, issue_number)Get details of a specific issue, including title, body, labels, assignees, and state.

gmailGmail17 methods

gmail.get-email(email_id)Fetch a Gmail message by ID.

gmail.get-profile()Get the authenticated Gmail user's profile.

gmail.search-messages(query=None, max_results=10)Search Gmail messages using a query string.

gmail.download-attachment(attachment)Download a single Gmail attachment.

gmail.download-all-attachments(email)Download all attachments from a Gmail message.

gmail.modify-message(message_id, add_label_ids=None, remove_label_ids=None)Add or remove labels on a Gmail message.

gmail.add-labels(message_id, add_label_ids)Add labels to a Gmail message.

gmail.remove-labels(message_id, remove_label_ids)Remove labels from a Gmail message.

gmail.mark-as-read(message_id)Mark a Gmail message as read.

gmail.mark-as-unread(message_id)Mark a Gmail message as unread.

gmail.archive(message_id)Archive a Gmail message (remove from Inbox).

gmail.star(message_id)Star a Gmail message.

gmail.unstar(message_id)Remove the star from a Gmail message.

gmail.trash-message(message_id)Move a Gmail message to trash.

gmail.setup-watch(topic_name)Set up Gmail push notifications via Google Cloud Pub/Sub.

gmail.list-user-history(history_id)List changes to the user's mailbox since a given history ID.

gmail.poll-messages(start_history_id)Poll for new Gmail messages since a given history ID.

godaddyGoDaddy4 methods

godaddy.check_availability(domain)Check if a domain name is available to register.

godaddy.bulk_check_availability(domains)Check availability of multiple domain names at once (up to 500).

godaddy.get_suggestions(query, limit=20, tlds=None)Get domain name suggestions based on a keyword or phrase.

godaddy.list_tlds()List all TLDs supported and enabled for sale (name and type only — GoDaddy does not return per-TLD pricing; use check_availability for prices).

gongGong.io9 methods

gong.transcript(dateFrom=None, dateTo=None, workspaceId=None, callIds=None, limit=100)Fetch call transcripts from Gong.

gong.get_extensive(call_id)Fetch detailed call metadata from Gong for a single call — parties (with name/email/affiliation) and CRM context (Account name, website, …). Pair with `transcript` to label speakerIds. Returns the call dict, or nil if Gong has no match.

gong.list_calls(fromDateTime=None, toDateTime=None, workspaceId=None, cursor=None, limit=100)List calls from Gong with optional date range and workspace filtering. Supports cursor-based pagination.

gong.list_users(cursor=None, include_avatars=false, limit=100)List users in the Gong account. Supports cursor-based pagination.

gong.get_highlights(call_ids, from_date_time=None, to_date_time=None)Fetch AI-generated highlights (Next Steps) for one or more Gong calls.

gong.get_scorecards(call_from_date=None, call_to_date=None, reviewed_user_ids=None, scorecard_ids=None, cursor=None)Fetch scorecard results from Gong for reviewed calls.

gong.list_library_folders(workspace_id=None)List Gong library folders, optionally filtered by workspace.

gong.get_library_content(folder_id, cursor=None)Get the calls and content inside a specific Gong library folder.

gong.list_trackers(workspace_id=None)List smart tracker definitions configured in Gong, optionally filtered by workspace.

google-driveGoogle Drive10 methods

google-drive.find-folder(name, parent_id=None, drive_id=None, page_size=None, page_token=None)Find a folder in Google Drive by name.

google-drive.create-folder(name, parent_id=None)Create a new folder in Google Drive.

google-drive.delete-folder(name, parent_id=None, drive_id=None)Delete a folder from Google Drive.

google-drive.find-files(parent_id=None, query=None, file_type="all", drive_id=None, page_size=None, page_token=None)List files in Google Drive, optionally filtered by folder.

google-drive.delete-files(file_name, parent_id=None, drive_id=None)Delete files from Google Drive by name.

google-drive.copy-files(file_name, destination_file_name, source_folder_id=None, destination_folder_id=None, drive_id=None)Copy a file to a new location in Google Drive.

google-drive.move-files(file_name, source_folder_id=None, destination_folder_id=None, destination_file_name=None, drive_id=None)Move a file to a different folder in Google Drive.

google-drive.download-files(file_id=None, file_name=None, output_format="base64")Download a file from Google Drive.

google-drive.create-files(file_name, create_type="content", content=None, parent_id=None, content_format="plain_text")Create a new file in Google Drive.

google-drive.upload-files(file, parent_id=None)Upload a local file to Google Drive.

google-mapsGoogle Maps6 methods

google-maps.geocode(address)Convert an address, city/state, or zip code to lat/lng coordinates.

google-maps.reverse_geocode(lat, lng)Convert lat/lng coordinates to a human-readable address.

google-maps.distance_matrix(origin, destination, travel_mode="driving", units="metric")Calculate travel time and distance between two points.

google-maps.nearby_search(lat, lng, radius=1000, type=None, keyword=None, max_results=20)Find places near a location by type or keyword.

google-maps.place_details(place_id, fields=None)Get detailed info about a specific place by place_id.

google-maps.timezone(lat, lng, timestamp=None)Get timezone information for a lat/lng location.

grok-searchXAI Grok Search1 method

grok-search.model_search(query, model="grok-4.20-0309-non-reasoning")Search X posts using Grok AI via the xAI Responses API.

hackernewsHacker News5 methods

hackernews.search(query=None, tags=None, numeric_filters=None, hits_per_page=20, page=0, restrict_searchable_attributes=None, typo_tolerance=None)Search Hacker News by relevance.

hackernews.search_by_date(query=None, tags=None, numeric_filters=None, hits_per_page=20, page=0, restrict_searchable_attributes=None, typo_tolerance=None)Search Hacker News by newest items first.

hackernews.front_page(hits_per_page=30, page=0)List current Hacker News front-page stories.

hackernews.get_item(id)Fetch a Hacker News item and its nested children.

hackernews.get_user(username)Fetch Hacker News user metadata.

hubspotHubSpot16 methods

hubspot.list_contacts(limit=50, after=None, properties=None, archived=False)List contacts with cursor pagination.

hubspot.get_contact(id, id_property=None, properties=None)Fetch a single contact by ID, or by email when id_property="email".

hubspot.create_contact(email=None, firstname=None, lastname=None, phone=None, company=None, properties=None, company_ids=None)Create a contact. Pass standard fields directly or use `properties` for custom fields.

hubspot.update_contact(id, properties)Patch properties on an existing contact by ID.

hubspot.search_contacts(filter_groups, properties=None, sorts=None, query=None, limit=10, after=None)Search contacts using HubSpot filterGroups syntax.

hubspot.list_companies(limit=50, after=None, properties=None, archived=False)List companies with cursor pagination.

hubspot.create_company(name=None, domain=None, industry=None, properties=None)Create a company.

hubspot.search_companies(filter_groups, properties=None, sorts=None, query=None, limit=10, after=None)Search companies using filterGroups syntax.

hubspot.list_deals(limit=50, after=None, properties=None, archived=False)List deals with cursor pagination.

hubspot.create_deal(dealname, amount=None, pipeline=None, dealstage=None, closedate=None, properties=None, contact_ids=None, company_ids=None)Create a deal. Optionally associate with existing contacts and companies.

hubspot.update_deal(id, properties)Patch properties on an existing deal by ID.

hubspot.search_deals(filter_groups, properties=None, sorts=None, query=None, limit=10, after=None)Search deals using filterGroups syntax.

hubspot.create_note(body, timestamp=None, owner_id=None, contact_ids=None, company_ids=None, deal_ids=None)Create a note engagement, optionally associated with CRM records.

hubspot.create_task(subject, body=None, due_timestamp=None, status="NOT_STARTED", priority="MEDIUM", task_type="TODO", owner_id=None, contact_ids=None, company_ids=None, deal_ids=None)Create a task engagement (to-do for a user) with associations.

hubspot.list_owners(limit=100, after=None, email=None)List workspace users (owners) for record ownership lookups.

hubspot.list_pipelines()List deal pipelines and their stage IDs (required for create_deal).

jiraJIRA5 methods

jira.get_ticket(ticket_id)Get a JIRA ticket by ID.

jira.get_tickets_by_time_span(query_type="date_range", start_date=None, end_date=None, start_ticket=None, end_ticket=None, max_results=None)List JIRA tickets filtered by date range or ticket number range.

jira.update_ticket(ticket_id, field_id, tag_name)Update fields and labels on a JIRA ticket.

jira.add_comment(ticket_id, comment_body, is_internal=False)Add a comment to a JIRA ticket.

jira.transition_ticket(ticket_id, transition_name="Done", resolution_name=None)Transition a JIRA ticket to a new workflow status.

linkedinLinkedIn6 methods

linkedin.get_profile()Get the authenticated user's LinkedIn profile.

linkedin.get_organization(organization_id)Get a LinkedIn company/organization page by numeric ID.

linkedin.list_posts(author_urn=None, count=10, start=0)List recent posts by a person or organization.

linkedin.create_post(text, visibility="PUBLIC", author_urn=None)Publish a text post on LinkedIn as the authenticated user.

linkedin.get_post_analytics(organization_urn, count=10)Get engagement analytics for an organization's posts.

linkedin.get_follower_count(organization_id)Get follower count for a LinkedIn organization.

makeMake29 methods

make.list_organizations()List organizations the user belongs to.

make.list_teams(organization_id)List teams in an organization.

make.get_current_user()Get the authenticated user's profile.

make.list_scenarios(team_id, pg_limit=10, pg_offset=0)List scenarios in a team.

make.get_scenario(scenario_id)Get a scenario by ID.

make.create_scenario(team_id, blueprint, scheduling=None, name=None)Create a scenario with a blueprint.

make.update_scenario(scenario_id, blueprint=None, scheduling=None, name=None)Update a scenario's name, blueprint, or scheduling.

make.delete_scenario(scenario_id)Delete a scenario.

make.run_scenario(scenario_id, data=None, responsive=true)Execute a scenario on demand. The scenario must be active.

make.activate_scenario(scenario_id)Activate (start) a scenario.

make.deactivate_scenario(scenario_id)Deactivate (stop) a scenario.

make.get_blueprint(scenario_id)Get a scenario's current blueprint JSON.

make.list_connections(team_id)List connections (third-party auth credentials) in a team.

make.get_connection(connection_id)Get a connection by ID.

make.test_connection(connection_id)Test whether a connection is valid.

make.list_data_stores(team_id)List data stores in a team.

make.get_data_store(data_store_id)Get a data store by ID.

make.create_data_store(team_id, name, datastructure_id, max_size_mb=1)Create a new data store.

make.delete_data_store(data_store_id)Delete a data store.

make.list_data_store_records(data_store_id, pg_limit=100, pg_offset=0)List records in a data store.

make.create_data_store_record(data_store_id, key=None, data=None)Create a record in a data store.

make.update_data_store_record(data_store_id, key, data)Update a record by key (partial merge).

make.delete_data_store_records(data_store_id, keys)Delete records from a data store by keys.

make.list_hooks(team_id)List webhooks in a team.

make.get_hook(hook_id)Get a webhook by ID.

make.create_hook(team_id, name, type_name)Create a webhook endpoint.

make.delete_hook(hook_id)Delete a webhook.

make.list_incomplete_executions(scenario_id, status=None)List failed/incomplete scenario runs.

make.retry_incomplete_execution(dlq_id)Retry a failed execution.

massiveMassive13 methods

massive.aggregates(ticker, multiplier, timespan, from, to, adjusted=True, sort=None, limit=None)OHLCV aggregate bars for a ticker over a date range. Multiplier + timespan (e.g. 5/minute, 1/day). `from`/`to` accept YYYY-MM-DD or unix-millis.

massive.previous_close(ticker, adjusted=True)Previous-day OHLCV bar for a ticker.

massive.last_quote(ticker)Most recent NBBO quote (bid/ask) for a ticker. Requires a paid plan for real-time.

massive.last_trade(ticker)Most recent trade for a ticker.

massive.ticker_details(ticker, date=None)Descriptive metadata for a ticker (name, market cap, description, branding, etc.).

massive.list_tickers(ticker=None, ticker_gte=None, ticker_gt=None, ticker_lte=None, ticker_lt=None, type=None, market=None, exchange=None, cusip=None, cik=None, date=None, search=None, active=True, order=None, limit=None, sort=None)Paginated reference list of tickers. Filter by exchange, type, market, CIK/CUSIP, or search.

massive.ticker_news(ticker=None, published_utc_gte=None, published_utc_gt=None, published_utc_lte=None, published_utc_lt=None, order=None, limit=None, sort=None)News articles index. Filter by ticker and publish-time range.

massive.options_chain(underlying_asset, strike_price_gte=None, strike_price_gt=None, strike_price_lte=None, strike_price_lt=None, expiration_date_gte=None, expiration_date_gt=None, expiration_date_lte=None, expiration_date_lt=None, contract_type=None, order=None, limit=None, sort=None)Snapshot of all options contracts for an underlying asset, with greeks and last quote. Use strike_price_gte/lte and expiration_date_gte/lte to filter.

massive.option_contract_snapshot(underlying_asset, option_contract)Snapshot of one specific options contract (e.g. O:AAPL250620C00200000).

massive.list_option_contracts(underlying_ticker=None, contract_type=None, expiration_date=None, expiration_date_gte=None, expiration_date_gt=None, expiration_date_lte=None, expiration_date_lt=None, strike_price_gte=None, strike_price_gt=None, strike_price_lte=None, strike_price_lt=None, as_of=None, expired=False, order=None, limit=None, sort=None)Reference list of historical and active option contracts.

massive.market_status()Current US market status (open/closed, after-hours, exchanges).

massive.exchanges(asset_class=None, locale=None)Reference list of exchanges Massive tracks.

massive.grouped_daily(date, adjusted=True, include_otc=False)Daily OHLCV bars for the entire US equities market on a single date. Returns ~8,000+ records in one call — ideal for market-wide scans.

microsoft_onedriveMicrosoft OneDrive19 methods

microsoft_onedrive.list-files(folder_path=None)List files in a folder.

microsoft_onedrive.search-files(query)Search for files by name or content.

microsoft_onedrive.upload-file(file_path, content, content_type=None)Upload a new file to OneDrive.

microsoft_onedrive.download-file(item_id=None, file_path=None)Download a file from OneDrive.

microsoft_onedrive.delete-file(item_id=None, file_path=None)Delete a file from OneDrive.

microsoft_onedrive.copy-file(item_id=None, file_path=None, destination_path)Copy a file to a new location.

microsoft_onedrive.move-file(item_id=None, file_path=None, new_name=None, destination_path=None)Move a file to a new location.

microsoft_onedrive.create-folder(folder_name, parent_path=None)Create a new folder in OneDrive.

microsoft_onedrive.get-metadata(item_id=None, file_path=None)Get file or folder metadata.

microsoft_onedrive.create-sharing-link(item_id=None, file_path=None)Create a sharing link for a file.

microsoft_onedrive.create-document(file_name, content, folder_path=None)Create a document from text content.

microsoft_onedrive.list-worksheets(workbook_id=None, workbook_path=None)List all worksheets in a workbook.

microsoft_onedrive.read-range(workbook_id=None, workbook_path=None, worksheet_name, range)Read a range of cells from a worksheet.

microsoft_onedrive.write-range(workbook_id=None, workbook_path=None, worksheet_name, range, values)Write values to a range of cells.

microsoft_onedrive.add-table-row(workbook_id=None, workbook_path=None, table_name, values, worksheet_name=None)Add a row to an existing table.

microsoft_onedrive.list-tables(workbook_id=None, workbook_path=None)List all tables in a workbook.

microsoft_onedrive.read-table(workbook_id=None, workbook_path=None, table_name)Read all rows from a table.

microsoft_onedrive.get-cell-value(workbook_id=None, workbook_path=None, worksheet_name, cell)Read a single cell value.

microsoft_onedrive.create-workbook(file_path)Create a new Excel workbook.

microsoft_teamsMicrosoft Teams8 methods

microsoft_teams.list-teams()List teams you have joined.

microsoft_teams.list-channels(team_id=None, team_name=None)List channels in a team.

microsoft_teams.send-channel-message(team_id=None, team_name=None, channel_id=None, channel_name=None, content)Send a message to a team channel.

microsoft_teams.send-chat-message(chat_id, content)Send a message to a 1:1 or group chat.

microsoft_teams.list-chats()List your chats.

microsoft_teams.create-channel(team_id=None, team_name=None, display_name, description=None)Create a new channel in a team.

microsoft_teams.list-channel-messages(team_id=None, team_name=None, channel_id=None, channel_name=None)List messages in a channel.

microsoft_teams.reply-to-message(team_id=None, team_name=None, channel_id=None, channel_name=None, message_id, content)Reply to a message in a channel.

mixpanelMixpanel11 methods

mixpanel.list_events(projectId)List all event names in a Mixpanel project.

mixpanel.list_event_properties(projectId, eventName, propertyName, fromDate, toDate, type="general", unit="day", limit=255)List properties for a specific Mixpanel event.

mixpanel.get_event_property_values(projectId, eventName, propertyName, limit=255)Get unique values for a Mixpanel event property.

mixpanel.run_segmentation_query(projectId, event, fromDate, toDate, type="unique", unit="day", where=None, on=None)Run a segmentation query to get event counts and unique users.

mixpanel.run_funnel_query(projectId, fromDate, toDate, funnelId=None, unit="day")Run a funnel query to analyze conversion across user journeys.

mixpanel.run_retention_query(projectId, fromDate, toDate, retention_type="birth", unit="day", born_event=None, event=None)Run a retention query to track user engagement over time.

mixpanel.query_profiles(projectId, where=None, page_size=1000, session_id=None, page=None)Query Mixpanel user profiles using the Engage API.

mixpanel.track_event(eventName, distinctId="anonymous", properties={})Track a single event in Mixpanel.

mixpanel.track_batch_events(events)Track multiple events in a single Mixpanel API call.

mixpanel.set_user_profile(distinctId, properties, operation="set")Update Mixpanel user profile properties.

mixpanel.increment_user_property(distinctId, properties)Increment numeric properties on a Mixpanel user profile.

mssqlAzure SQL1 method

mssql.execute_query(query, output_format="json_rows", query_timeout=30000, retry_attempts=4)Execute a SQL query against an Azure SQL database.

namecheapNamecheap3 methods

namecheap.check_availability(domains)Check availability of up to 50 domain names at once.

namecheap.get_tld_pricing(action="REGISTER", product_category=None)Get registration pricing for all TLDs or a specific category.

namecheap.get_domain_info(domain)Get registration details for a domain in your account.

namecheap_aftermarketNamecheap Aftermarket4 methods

namecheap_aftermarket.list_sales(cursor=None, order_by=None, direction=None, ids=None, name=None, price=None, tld=None, start_date=None, end_date=None, keywords=None, age=None, backlinks_count=None, bid_count=None, extensions_taken=None, name_length=None, cloudflare_ranking=None, no_hyphens=None, no_numbers=None, only_numbers=None, nsfw=None)List auction sales with cursor-based pagination and rich filtering (price range, TLD, age, backlinks, rankings).

namecheap_aftermarket.get_sale(sale_id)Fetch a single auction sale by its opaque sale ID (returned by list_sales).

namecheap_aftermarket.list_my_bids(page=None, page_size=None, sale=None)List the authenticated user's bids with page-based pagination.

namecheap_aftermarket.place_bid(sale_id, max_amount)Place a proxy bid on a sale. The system automatically bids the minimum needed to win, up to max_amount.

opensearchOpenSearch3 methods

opensearch.search(index, body, size=10, request_timeout=60000)Execute a search query against an OpenSearch index.

opensearch.list_indices(request_timeout=60000)List all indices in the OpenSearch cluster.

opensearch.get_mapping(index, request_timeout=60000)Get the field mapping for an OpenSearch index.

outlook_mailMicrosoft Outlook Mail14 methods

outlook_mail.get-message(message_id)Get a specific Outlook message by ID.

outlook_mail.list-messages(folder_id=None, filter=None, top=None)List messages in the user's Outlook mailbox.

outlook_mail.send-message(to_recipients, subject, body=None, cc_recipients=None)Send an email via Outlook.

outlook_mail.create-draft(to_recipients, subject, body=None)Create a draft email in Outlook.

outlook_mail.delete-message(message_id)Delete an Outlook message by ID.

outlook_mail.download-attachment(message_id, attachment_id)Download an attachment from an Outlook message.

outlook_mail.list-attachments(message_id)List attachments on an Outlook message.

outlook_mail.move-message(message_id, destination_folder_id)Move an Outlook message to a different folder.

outlook_mail.mark-as-read(message_id, is_read)Mark an Outlook message as read or unread.

outlook_mail.update-message(message_id, categories=None)Update properties of an Outlook message.

outlook_mail.list-categories()List available Outlook message categories.

outlook_mail.list-folders(parent_folder_id=None)List mail folders in the user's Outlook mailbox.

outlook_mail.get-initial-delta(folder_id)Get initial delta state for tracking Outlook message changes.

outlook_mail.poll-delta(delta_link)Poll for Outlook message changes using a delta link.

pipedrivePipedrive14 methods

pipedrive.get_deal(deal_id)Get a single deal by ID.

pipedrive.search_deals(term="", limit=10)Search deals by term.

pipedrive.get_deals(limit=None, cursor=None, status=None, sort_by=None, sort_direction=None)List deals with filtering.

pipedrive.create_deal(title, person_id=None, org_id=None, value=None, currency=None, stage_id=None, status=None)Create a new deal.

pipedrive.update_deal(deal_id, title=None, person_id=None, org_id=None, value=None, status=None)Update an existing deal.

pipedrive.get_person(person_id)Get a single person by ID.

pipedrive.search_persons(term="", limit=10)Search persons by term.

pipedrive.create_person(name, email=None, phone=None, org_id=None)Create a new person.

pipedrive.get_organization(organization_id)Get a single organization by ID.

pipedrive.search_organizations(term="", limit=10)Search organizations by term.

pipedrive.create_organization(name)Create a new organization.

pipedrive.get_activities(limit=None, cursor=None, deal_id=None, person_id=None, org_id=None)List activities.

pipedrive.create_activity(subject, type=None, due_date=None, note=None, deal_id=None, person_id=None, org_id=None)Create a new activity.

pipedrive.create_note(content, deal_id=None, person_id=None, org_id=None)Create a note on a deal, person, or organization.

postgresPostgreSQL1 method

postgres.execute_query(query, output_format="json_rows", query_timeout=30000)Execute a SQL query against a PostgreSQL database.

redditReddit10 methods

reddit.subreddit(subredditName, filterType="hot", timeFilter="all", limit=10, after=None, before=None, flair=None)Fetch posts from a subreddit.

reddit.comment(postId, limit=100, sort="top", context=0)Fetch comments from a Reddit post.

reddit.search(query, sort="relevance", timeFilter="all", limit=25, after=None, before=None)Search across all of Reddit.

reddit.search_subreddit(subredditName, query, sort="relevance", timeFilter="all", limit=25, after=None, before=None)Search within a specific subreddit.

reddit.user_info(username)Get public profile information for a Reddit user.

reddit.user_posts(username, sort="new", timeFilter="all", limit=25, after=None, before=None)Get posts submitted by a Reddit user.

reddit.user_comments(username, sort="new", timeFilter="all", limit=25, after=None, before=None)Get comments submitted by a Reddit user.

reddit.subreddit_info(subredditName)Get metadata and statistics for a subreddit.

reddit.subreddit_rules(subredditName)Get the rules for a subreddit.

reddit.subreddit_flairs(subredditName)List available post flairs for a subreddit.

serpSERP1 method

serp.search(search_string, search_engine="google", location=None, time_period=None)Search the web via SerpAPI and return structured results.

sftpSFTP / FTP6 methods

sftp.list_files(path="/", timeoutSeconds=30)List directory entries on the SFTP/FTP server.

sftp.get_file_size(path, timeoutSeconds=30)Return the byte size of a remote file.

sftp.get_row_count(path, hasHeader=True, chunkSize=1000, timeoutSeconds=30)Count data rows in a remote CSV file.

sftp.read_chunk(path, startRow, rowCount, hasHeader=True, timeoutSeconds=30)Read a bounded slice of rows from a remote CSV file.

sftp.download_file(path, contentType=None, timeoutSeconds=120)Download a remote file and return it as a qbash file-reference object.

sftp.read_lines(path, lineCount, offset=0, timeoutSeconds=30)Read raw text lines from a remote file.

slackSlack11 methods

slack.create_message(channel, text)Send a message to a channel.

slack.reply_to_thread(channel, text, thread_ts)Reply to a message thread.

slack.get_user_profile(user_id)Get a user's profile information.

slack.look_up_user_by_email(email)Find a user by their email address.

slack.download_file(file)Download a file shared in Slack.

slack.get_conversation_history(channel, oldest=None, latest=None, limit=100, cursor=None, inclusive=False)Fetch messages from a channel within a date range.

slack.get_conversation_replies(channel, thread_ts, oldest=None, latest=None, limit=100, cursor=None, inclusive=False)Fetch all replies in a thread.

slack.list_users(limit=100, cursor=None, include_locale=False)List all users in the workspace.

slack.list_conversations(types="public_channel", limit=100, cursor=None, exclude_archived=False)List all channels/conversations accessible to the bot.

slack.get_conversation_info(channel, include_locale=False, include_num_members=False)Get detailed information about a specific channel.

slack.get_conversation_members(channel, limit=100, cursor=None)List all member user IDs in a channel.

supabaseSupabase14 methods

supabase.list_projects()List all accessible Supabase projects.

supabase.get_project(projectRef)Get details for a specific Supabase project.

supabase.list_organizations()List organizations the user is a member of.

supabase.get_organization(orgId)Get details for a specific Supabase organization.

supabase.list_tables(projectRef=None, schema="public")List tables in a Supabase database schema.

supabase.list_extensions(projectRef=None)List installed PostgreSQL extensions for a Supabase project.

supabase.list_migrations(projectRef=None)List database migration history for a Supabase project.

supabase.apply_migration(migrationName, statements, projectRef=None)Apply a SQL migration to a Supabase database.

supabase.execute_sql(query, projectRef=None)Execute a raw SQL query against a Supabase database.

supabase.get_logs(projectRef=None, isoTimestampStart=None, isoTimestampEnd=None)Retrieve project logs from Supabase for debugging.

supabase.list_storage_buckets()List all storage buckets in a Supabase project.

supabase.create_storage_bucket(bucketName, public=False, fileSizeLimit=None, allowedMimeTypes=None)Create a new storage bucket in Supabase.

supabase.get_storage_bucket(bucketId)Get details about a specific Supabase storage bucket.

supabase.list_storage_files(bucketId, prefix=None, limit=None, offset=None)List files in a Supabase storage bucket.

supadataSupadata.ai4 methods

supadata.scrape_web(url)Scrape content from a single web page.

supadata.map_website(url)Map an entire website to discover all URLs and structure.

supadata.scrape_youtube_transcript(videoId, lang=None, text=None, chunkSize=None)Extract the transcript from a YouTube video.

supadata.scrape_youtube_channel(channelId, limit=None, channelType=None)Get videos from a YouTube channel.

telegramTelegram17 methods

telegram.send_message(chat_id, text, parse_mode=None, disable_web_page_preview=None, disable_notification=None, reply_to_message_id=None, reply_markup=None)Send a text message to a chat.

telegram.send_photo(chat_id, photo, caption=None, parse_mode=None, disable_notification=None, reply_to_message_id=None)Send a photo to a chat.

telegram.send_document(chat_id, document, caption=None, parse_mode=None, disable_notification=None, reply_to_message_id=None)Send a document to a chat.

telegram.edit_message(chat_id, message_id, text, parse_mode=None, reply_markup=None)Edit a previously sent message.

telegram.delete_message(chat_id, message_id)Delete a message from a chat.

telegram.send_poll(chat_id, question, options, is_anonymous=None, type=None, correct_option_id=None)Send a poll to a chat.

telegram.get_updates(offset=None, limit=100, timeout=0, allowed_updates=None)Poll for new incoming updates.

telegram.get_chat(chat_id)Get detailed info about a chat.

telegram.get_chat_member_count(chat_id)Get the member count of a chat.

telegram.set_webhook(url, max_connections=None, allowed_updates=None, secret_token=None)Configure a webhook URL for receiving updates.

telegram.get_me()Get basic info about the bot (test connection).

telegram.pin_message(chat_id, message_id, disable_notification=None)Pin a message in a chat.

telegram.unpin_message(chat_id, message_id=None)Unpin a message in a chat.

telegram.set_chat_title(chat_id, title)Set the title of a chat.

telegram.set_chat_description(chat_id, description="")Set the description of a chat.

telegram.leave_chat(chat_id)Leave a group, supergroup, or channel.

telegram.send_chat_action(chat_id, action)Send a chat action like typing indicator.

twistTwist27 methods

twist.list_workspaces()List all workspaces the user belongs to.

twist.get_current_user()Get the authenticated user's profile.

twist.list_channels(workspace_id)List channels in a workspace.

twist.get_channel(id)Get a channel by ID.

twist.create_channel(workspace_id, name, description=None, color=None)Create a channel in a workspace.

twist.update_channel(id, name, description=None)Update a channel.

twist.archive_channel(id)Archive a channel.

twist.list_threads(channel_id, filter_by=None, newer_than_ts=None, older_than_ts=None, limit=30)List threads in a channel.

twist.get_thread(id)Get a thread by ID.

twist.create_thread(channel_id, title, content, recipients=None, send_as_integration=None)Create a thread in a channel.

twist.update_thread(id, title=None, content=None)Update a thread's title or content.

twist.remove_thread(id)Delete a thread.

twist.list_comments(thread_id, newer_than_ts=None, older_than_ts=None, limit=30)List comments in a thread.

twist.get_comment(id)Get a comment by ID.

twist.create_comment(thread_id, content, send_as_integration=None)Add a comment to a thread.

twist.update_comment(id, content)Update a comment.

twist.remove_comment(id)Delete a comment.

twist.list_conversations(workspace_id)List direct message conversations.

twist.get_conversation(id)Get a conversation by ID.

twist.get_or_create_conversation(workspace_id, user_ids)Get or create a DM conversation with specified users.

twist.list_messages(conversation_id, newer_than_ts=None, older_than_ts=None, limit=30, cursor=None)List messages in a conversation.

twist.get_message(id)Get a message by ID.

twist.create_message(conversation_id, content)Send a direct message.

twist.update_message(id, content)Update a message.

twist.remove_message(id)Delete a message.

twist.search(query, workspace_id, channel_id=None, limit=30, cursor=None)Search threads and comments across a workspace.

twist.search_conversation(query, conversation_id, limit=None, cursor=None)Search messages within a conversation.

typeformTypeform18 methods

typeform.list_workspaces(page=None, page_size=10, search=None)List all workspaces.

typeform.get_workspace(workspace_id)Get a workspace by ID.

typeform.list_forms(workspace_id=None, search=None, page=None, page_size=10)List forms, optionally filtered by workspace.

typeform.get_form(form_id)Get a form definition by ID (fields, logic, settings).

typeform.create_form(title, type=form, fields, settings=None, logic=None, welcome_screens=None, thankyou_screens=None, theme_href=None, workspace_href=None, hidden=None, variables=None)Create a new form with fields, settings, and logic.

typeform.update_form(form_id, title, type=None, fields, settings=None, logic=None, welcome_screens=None, thankyou_screens=None, hidden=None, variables=None, theme_href=None, workspace_href=None)Full-replace a form definition (PUT). Use get_form first to preserve unchanged fields.

typeform.delete_form(form_id)Delete a form.

typeform.list_responses(form_id, page_size=25, since=None, until=None, after=None, before=None, completed=None, query=None, fields=None)List form responses with filtering and pagination.

typeform.delete_responses(form_id, included_response_ids)Delete form responses by response ID(s).

typeform.list_images()List all images in the account.

typeform.get_image(image_id)Get image details and URLs by ID.

typeform.upload_image(file_name, image=None, url=None)Upload an image (base64 or URL).

typeform.delete_image(image_id)Delete an image.

typeform.list_themes(page=None, page_size=10)List all themes.

typeform.get_theme(theme_id)Get a theme by ID.

typeform.create_theme(name, colors=None, font=None, has_transparent_button=None, background=None)Create a custom theme.

typeform.update_theme(theme_id, name, colors, font, has_transparent_button=None, background=None, visibility=None, rounded_corners=None)Full-replace a theme (PUT). Use get_theme first to preserve unchanged fields.

typeform.delete_theme(theme_id)Delete a theme.

xX11 methods

x.get_me()Return the authenticated user's profile (requires OAuth user context).

x.create_tweet(text, reply_to_tweet_id=None)Publish a new tweet (requires OAuth user context).

x.get_user(username)Look up a public user profile by username.

x.get_tweet(tweet_id)Fetch a single tweet with public engagement metrics.

x.get_tweet_metrics(tweet_id)Fetch a tweet with extended metrics including non_public_metrics and organic_metrics for tweets authored by the authenticated user.

x.list_user_tweets(user_id, max_results=10, pagination_token=None, start_time=None, end_time=None)List recent tweets from a user by their numeric user ID.

x.search(query, max_results=10, allowed_x_handles=None, excluded_x_handles=None, from_date=None, to_date=None)Search recent posts on X using the X API v2.

x.user_mentions(username, max_results=10)Fetch recent @mentions of a user by username.

x.tweet_counts(query, granularity="hour")Get recent tweet volume counts for a search query.

x.user_timeline(username, max_results=10, exclude=None)Fetch recent posts from a user's timeline by username.

x.trends(woeid=1)Get trending topics for a location by WOEID.

xeroXero21 methods

xero.create_invoice(contact_id, line_items=None, due_date=None, invoice_number=None, reference=None)Create a new sales invoice.

xero.update_invoice(invoice_id, status=None, due_date=None)Update an existing invoice.

xero.get_invoice(invoice_id)Get a single invoice by ID.

xero.list_invoices(status=None, contact_id=None, page=None)List invoices with optional filters.

xero.void_invoice(invoice_id)Void an existing invoice.

xero.send_invoice(invoice_id)Email an invoice to the contact.

xero.create_bill(contact_id, line_items=None, due_date=None, status=None)Create a new bill (accounts payable).

xero.list_bills(page=None)List all bills.

xero.create_contact(name, email_address=None, phone=None, is_customer=None, is_supplier=None)Create a new contact.

xero.update_contact(contact_id, name=None, email_address=None)Update an existing contact.

xero.get_contact(contact_id)Get a single contact by ID.

xero.list_contacts(where=None, page=None)List contacts with optional filters.

xero.create_payment(invoice_id, account_id, amount, date=None, reference=None)Record a payment against an invoice.

xero.list_payments(status=None, page=None)List payments.

xero.create_credit_note(contact_id, line_items=None, type=None)Create a credit note.

xero.list_credit_notes(status=None)List credit notes.

xero.create_purchase_order(contact_id, line_items=None, delivery_date=None)Create a purchase order.

xero.get_purchase_order(purchase_order_id)Get a purchase order by ID.

xero.create_item(code, name, description=None, sales_unit_price=None, purchase_unit_price=None)Create a new item/product.

xero.list_items()List all items.

xero.list_accounts(account_type=None)List chart of accounts.

zoomZoom11 methods

zoom.search_meetings(from_date, to_date, topic=None, limit=30)Search past Zoom meetings by date range and optional topic keyword.

zoom.get_meeting(meeting_id)Get details for a specific past Zoom meeting (topic, duration, host, time).

zoom.list_participants(meeting_id, limit=100)List participants of a past Zoom meeting with join/leave times.

zoom.get_transcript(meeting_id, format=text)Fetch the transcript of a recorded Zoom meeting. Returns speaker-labeled text by default, or raw VTT with format='vtt'.

zoom.get_meeting_chat(meeting_id)Fetch the in-meeting chat log from a recorded Zoom meeting.

zoom.get_meeting_polls(meeting_id)Get poll questions and participant responses from a past Zoom meeting.

zoom.get_meeting_qa(meeting_id)Get Q&A questions and answers from a past Zoom meeting or webinar.

zoom.get_meeting_summary(meeting_id)Get the Zoom AI-generated meeting summary (requires AI Companion enabled in Zoom settings).

zoom.list_users(status=active, limit=100)List users in the Zoom account. Requires an Admin or Server-to-Server credential.

zoom.search_account_meetings(from_date, to_date, type=past, limit=100)Search past meetings across all users in the Zoom account via the Dashboard API. Requires Business+ plan and an Admin or S2S credential.

zoom.search_user_meetings(user_id, from_date, to_date, topic=None, limit=30)Search past meetings for a specific user in the Zoom account. Requires an Admin or S2S credential.

zoominfoZoomInfo7 methods

zoominfo.search_contacts(firstName=None, lastName=None, email=None, jobTitle=None, companyName=None, department=None, managementLevel=None, country=None, state=None, page=1)Search for B2B contacts by name, title, company, or location.

zoominfo.search_companies(companyName=None, industry=None, country=None, state=None, page=1)Search for B2B companies by name, industry, revenue, or location.

zoominfo.search_intent(topics, page=1)Search for buyer intent signals by topic.

zoominfo.enrich_contact(email=None, firstName=None, lastName=None, companyName=None)Enrich a contact with full details including email, phone, and social profiles.

zoominfo.enrich_company(companyName=None, companyId=None)Enrich a company with full firmographic details.

zoominfo.enrich_intent(companyId, topics)Get buyer intent signals for a specific company and topics.

zoominfo.get_usage()Check ZoomInfo API usage and remaining credits.