Reduck AI

Reduck MCP allows agents to discover, run and create browser automation scripts that serve as tools.

От сообществаРаботаетБез входаГлобальныйБесплатноМожет изменять данные

Что умеет

Start Session: Only needed for `exec_code` authoring/discovery — `run_script` opens its own browser. Start a browser session on your paired browser — omit `deviceId` to auto-pick the paired extension,
Stop Session: Close a session's browser.
Exec Code: Authoring/discovery escape hatch — first check `list_scripts`; if a saved script fits, `run_script` it instead. Use this only to build or debug a script when none does; it needs `start_sess

Какие данные видит

Нужен ли аккаунт

Не нужен: сервер работает без входа

Reduck MCP allows agents to discover, run and create browser automation scripts that serve as tools. Scripts run in your own Chrome, through our extension, which allows your agent to work where you are logged in — no credentials exposure, and same fingerprints so no bot detection.

Список инструментов сервера (25)

Технические названия из tools/list. Нужны только разработчикам.

start_session	Only needed for `exec_code` authoring/discovery — `run_script` opens its own browser. Start a browser session on your paired browser — omit `deviceId` to auto-pick the paired extension, or pass one from list_devices. Returns a sessionId (pass it to exec_code / loadCookiesFromBrowser / stop_session) plus the authoring doc itself. Each session is a fresh browser — no cookies or signed-in state carry over from a previous one. Sessions survive MCP reconnects and expire after 15 min idle.
stop_session	Close a session's browser.
exec_code	Authoring/discovery escape hatch — first check `list_scripts`; if a saved script fits, `run_script` it instead. Use this only to build or debug a script when none does; it needs `start_session` first. Runs an async JS body against a session (extension device recommended). In scope: `builtins` (actions), `buildutils` (recon), `ai` (LLM), `page` (escape hatch — prefer a builtin). The full builtin/buildutil/ai catalog + ReduckSelector grammar live in read_docs({name:"authoring_scripts"}) — read it for the full reference.
list_scripts	List the scripts you can run: your own, those of projects you belong to, and the official catalogue. Each row is `@handle/host/slug [sideEffects] — description`; the prefix is exactly how you address it in run_script. `[none]` means the script only observes the site, `[write]` that it creates, changes or deletes something; an unmarked row is one nobody has declared, so assume it may write. Returns one bounded page; a trailer flags more — tighten filters or page through.
read_script	Read a script by (host, slug): name, description, visibility, loggedIn, sideEffects, updatedAt, input + output JSON Schemas. Omit `handle` for your own scripts; pass a user handle prefixed with @ to read that user's public script, or a project handle (without @) to read a project's script. Pass `includeScript:true` to also return the raw code body (e.g. to inspect before editing). Pass `version_id` to read a specific version instead of the current one (from list_script_versions).
read_docs	Loads the documentation on how to use Reduck. Omit `name` for the overview — it ends with an index of the other docs (e.g. "authoring_scripts"); pass a name from that index to load it.
create_script	Create a new script identified by (host, slug) — fails if it already exists (then use create_draft_script_version). At run time the script's scope is exec_code's minus `buildutils`. Set `loggedIn: true` when the script needs an authenticated session — run_script then fetches the host's cookies from the agent and injects them before the body runs.
create_draft_script_version	Create a new draft version of an existing script — persisted in the DB but NOT yet linked as the script's current version. Use run_script with the returned version_id to test, then promote_script_version to make it current. (Display metadata — name, description, visibility — is separate: update_script_metadata.) Provide the full code body and schemas for the new version.
patch_draft_script_version	Update a draft version's code, schemas, or note in place — without creating a new version. Only works on draft versions (not yet promoted). Pass only the fields you want to change; omitted fields stay as they are.
update_script_metadata	Update a script's display metadata — name, description, and/or visibility. Applies immediately: no buffer, no commit, no new version. `visibility: "public"` lists the script in the community catalogue; "private" reverts to owner-only.
delete_draft_script_version	Discard a draft version — an abandoned attempt, or a duplicate. Only drafts can be deleted; a promoted version stays.
promote_script_version	Promote a script version to be the script's current version. If the version is a draft, it is marked as non-draft. Use this to 'commit' a draft as the official new version, or to roll back to an older version if the current one is buggy.
archive_script	Archive a script by (host, slug) — it leaves list/read/run but stays recoverable via the API for 30 days, then is purged.
unarchive_script	Restore a previously archived script by (host, slug) — reverses an archive, making the script fully editable and runnable again.
list_script_versions	List versions of a script you own, newest first. Each row shows the version ID, version number, draft status, note, and creation date. Use version IDs with read_script, run_script, promote_script_version, or delete_draft_script_version. Returns one bounded page; a trailer flags more.
read_host_readme	Read the README for a host — the notes an owner shares across every script targeting that site, like rate limits, login quirks, or ordering rules. Returns the current text or empty if none exists.
set_host_readme	Write the README for a host — guidance shared across every script targeting that site. Calling it again replaces the previous text (idempotent upsert). You need edit access to the owner's scripts.
delete_host_readme	Delete a host's README. You need edit access to the owner's scripts. Idempotent — succeeds even if no README exists.
run_script	Run a saved script on your paired browser. One script: `script` — {host, slug, handle?, args?}, e.g. {"script":{"host":"doctolib.fr","slug":"search_practitioners","handle":"@reduck","args":{…}}}. Omit `handle` for your own scripts; pass a user handle prefixed with @ or a project handle (without @) to run that owner's public script. If the script declares loggedIn:true, its host's cookies are fetched from the user's device and injected before the body runs Several at once: `scripts` — a list of those same objects, each run on its OWN browser, all at the same time. They share nothing and one failing doesn't stop the others, so you get one outcome per entry, in the order you passed them. This is how to fan out: one call, not N. Each entry carries its own `args`; arguments always belong to the script that uses them, never to the run. Pass exactly one of `script` / `scripts`. Always returns a stable {runId, status, ...} envelope: `completed` carries `result`, `failed` carries `error`; a run outliving `waitForSeconds` returns `queued`/`running` + `retryAfterMs` — poll read_run_results({runId}) for the outcome. `scripts` returns one envelope per script plus a `batchId` — read_run_results({batchId}) reports all of them at once. A device runs a few scripts at once (its concurrency budget, editable on the devices page); extras queue FIFO, so `queued` means busy — not offline. Pass `sessionId` while authoring to run one `script` in that open session's browser instead — no new browser, no queue, the page stays live for exec_code after the run, and the step trace comes back inline. Without sessionId no trace is returned; read_run_trace({runId}) has it. `browser` defaults to your paired browser.
list_runs	List your past runs (from run_script), newest first, as `<runId> <name> <script> <status> <started_at>`. The runId is how you address read_run_results / read_run_trace. `status` filters to one outcome (e.g. "error" to find failures); omit for all. Returns one bounded page; a trailer flags more — page through.
read_run_results	Return a run's output by id: the result value (✓, YAML preview) or its error (❌). Works while a run is still queued/running — you get the same {runId, status, retryAfterMs} envelope run_script returns; poll until terminal. Pass `batchId` instead of `runId` to report every script of a `scripts` batch in one call (one envelope each). structuredContent carries the result unclipped. No screenshots here: the step trace and its screenshots live in read_run_trace — use it to debug a failed run.
read_run_trace	Return a past run's evidence by id (from list_runs): the same facts the error classifier reasons over — run facts, the pinned script code, a compact step trace, and the failing + final screenshots. No verdict: it's for you to judge what happened. Most useful on a failed run; for a run's output use read_run_results.
loadCookiesFromBrowser	Fetch cookies for `domain` from the user's browser (via their paired extension device) and inject them into the session's sandbox browser so it is authenticated as the user.
whoami	Show which Reduck account this MCP token is authenticated as (handle, name, email, projects). Returns a local/unauthenticated note when running against a local no-auth MCP.
list_devices	List the user's paired devices. Extension devices are recommended and preferred by default (woken automatically when targeted). Pass a listed id to start_session/run_script as `deviceId`; omit it to auto-pick the extension.