Python SDK reference

Connection settings for the platform API.

Replace the default client, e.g. noclick.configure(api_key="nk_live_...").

Get the client used when no client= is given, built from the environment on first use.

One page of a listing; pass next_cursor back as cursor for the next (None = the last page).

Every region, or those that place kind ("sandbox", "agent", "bucket", "database", "project", "machine", "browser", "dict" or "queue"; any other raises noclick.InvalidRequest naming those that are placed by region).

A place NoClick runs resources and keeps their data; region= takes its name.

One of your users, a person or a company, known by your own id for it.

Whether a user can spend right now, as user.spending reads it.

Act for user inside the block: a User, your id for the user, or None for the account itself.

A token pinned to one user with a subset of the minting key's scopes.

One per account; rendered on /h/ pages and human emails.

A named connection to an account on another service.

Run one operation by its ref, "name.operation", as tools= names it.

A connect page URL that is also the operation tracking it.

A service NoClick can operate, such as gmail, or a model provider an agent thinks with, such as anthropic: one of Connection.integrations().

One operation of a connection's integration, with the JSON schema of the parameters connection.run takes for it.

An app event a connection's integration can deliver to an agent's noclick.OnEvent trigger or a channel's subscription: its name (channel_message, contact_created), what it means, and filters, the keyword arguments that narrow it, each with what it matches (one marked Required. must be given).

A hosted agent.

What can run an agent: one of Agent.harnesses().

What an agent's model calls on your own key or plan (its model_connection) used: tokens in (cached_tokens of them read from the provider's cache), tokens out, and what they come to in US dollars at the provider's list price.

A connection the agent's user gave it at run time (it asked with its request_connection tool, within can_request).

A schedule: a five-field cron expression (minute, hour, day of month, month, day of week: numbers, *, ranges, steps, lists and month or day names) read in a timezone, so "0 9 * * 1-5" with tz="America/New_York" means 9am New York time on weekdays, daylight saving included.

A URL that wakes the agent: each POST to it is a turn, its body the message (a JSON body is passed as JSON).

An app event from one of the agent's connections, such as a Slack message or a new HubSpot contact.

One of NoClick's own events (the types noclick.Event.types() lists, as your webhooks receive them): an operation failing, a connection breaking, a channel halting, a workflow's run failing, an agent built in the app asking for you, a payment going through.

Each message on a queue becomes a turn: the agent reads message (its standing instructions, if any) and then the message's JSON body.

One thing that wakes an agent, as agent.triggers() reads it.

agent.memory: named notes the agent keeps across conversations.

Named notes any agent of its scope can attach: the account's (every user's agents may read them) or one user's.

The files an agent works on in one conversation: what it writes with its shell or its tools, and what you put there for it.

An agent's public chat page.

A turn an agent will take later, in one of its conversations: at a time, when an operation settles, on a NoClick event, or at each time of a schedule (agent.wake, or its own wake_me tool).

Work one agent gave another: a spawned child's task (kind agent.task), or a message a coordinator sent with its agents tools (kind agent.message), whose only update is done.

An update the parent requires before its child makes a tool call: Before with tool patterns written as policy writes them ("gmail.send_email_message", "stripe.*", "code").

An update the parent requires at least this often while its child works: Every with an interval in seconds (or a timedelta), 60 seconds or more.

The agents capability, for an agent's tools: the same as the string "agents", narrowed with Agents.only(...).

NoClick itself, for an agent's tools: the same as the string "noclick", narrowed with Platform.only(...).

A file on a message, kept as an account file at url.

A conversation between members.

Events a channel, or a whole noclick.Workspace's channels, hear: an app's events through a connection, a webhook URL, or NoClick's own events.

A home for channels and their members, like a workspace in a team chat: a company, a client or a team, with its people, its agents and its rooms.

A remote agent reached over A2A.

A set of tools for your LLM.

The outcome of one tool call.

Your tools at one URL, for Claude, ChatGPT, Cursor or any MCP client.

Models paid from your NoClick balance, for code that isn't an agent: chat, embeddings, images, videos and transcription; and your agents as agent:<name> models.

A person to reach.

Some of a person's tools for an agent (human.only(...)), for tools=.

A request to a person; also the operation that finishes when they answer.

The account's policy, or one user's (user_id).

An email address that receives mail.

A number you own.

A running browser.

Saved sign-ins for one person.

A live-browser link where a person signs in to a site, and the operation that finishes once they have: wait() returns the SiteLogin.

A virtual card with a spending limit.

A running sandbox.

An always-on computer of a fixed size in one region, billed a flat monthly price.

An app: a repo deployed to a URL.

One build of a project at one commit.

A project's cron job: NoClick POSTs path on the app on every tick of cron (read in tz).

app.email: transactional email from the app's own address (receipts, booking confirmations), rate-capped and charged per recipient; a high bounce or complaint rate pauses sending.

app.payments: take payments in the app without a payments account of your own.

app.sign_in: accounts for the app's own users.

app.ai: noclick.AI acting as the app, from the app's own code (Project.current()).

A git repository NoClick hosts.

A domain you bought through NoClick, transferred in, or connected from elsewhere, and what it serves.

A domain bought or renewed: the operation Domain.buy and domain.renew return.

A workflow built in the NoClick app: its trigger, steps and outputs.

A SQL database: SQLite (engine="sqlite", the default, cheap while idle) or Postgres.

A bucket of files by key.

A persistent filesystem: files by path, in folders, that outlive the sandbox or agent turn that wrote them.

A key-value store: string keys, JSON values, optional expiry per key.

A durable queue of JSON messages, delivered at least once.

Named values, such as API keys, that the code you run reads from its environment: a sandbox's commands, an agent's shell, an app.

A long-running piece of work.

Something deleted, restorable until purge_after.

Something that happened: an operation finished, a person answered, a domain went live.

An endpoint on your server that receives events, signed with its secret.

One recorded tool call.

One logged request.

Spend for period ("month"), optionally split group_by "user", "key", "agent" or "project" (each app), and narrowed to one agent (an Agent or its id).

What the account (or the current user) spent in period.

What an export produced: a zip at url (a link that works until expires_at, 7 days) of size_bytes, what's in it, and remaining_dependencies, what keeps needing NoClick while the account exists (the agent runtime, channels, people's pending asks, app hosting, connections).

Tell the NoClick team something: a bug, an idea, or anything (general).

Base class for every NoClick platform error.

The connection has no account connected yet; send the person connect_url.

The connection's account was revoked or stopped working; send the person connect_url to reconnect it (same name).

Policy wants a person to approve this call first.

A monthly spend cap (scope: key, user, agent, ...) is used up.

You paused this user's spending (user.pause_spending()), so nothing that costs money runs for them until user.resume_spending().

It already exists (existing_id names it), or another call holds it, like a conversation mid-turn.

A webhook delivery's NoClick-Signature doesn't match its body, or its timestamp is too old.