What can NoClick actually do with Reducto?

The Reducto node parses documents into structured markdown or JSON, extracts named fields, classifies document types, and splits multi-document files into their parts. It can also run your saved Reducto pipelines and upload files to process. Each of these is a separate operation you can wire to any trigger.

Can a workflow react when a Reducto job finishes?

Yes. Reducto processes large documents as async jobs, and the On Job Completed trigger starts a workflow the moment a job finishes so you can act on the result right away. You can pair it with the Configure Webhook operation to register where Reducto sends those completion events.

How do I connect Reducto to NoClick?

The node authenticates with a Reducto API key. Create one in Reducto Studio under API Keys, then paste it into the node's credential field. Once connected, every operation runs against your Reducto account.

Can it handle documents that take a while to process?

Yes. The Parse, Extract Fields, Split, and Run Pipeline operations each have an async variant that returns a job you can track. Use Get Job to poll status, List Jobs to see what's running, and Cancel Job to stop one that is no longer needed.

Can it pull specific fields instead of the whole document?

Yes. The Extract Fields operation returns only the values you ask for, such as an invoice total or a contract date, rather than the entire parsed document. That keeps downstream steps focused on the exact data you need to store or act on.

What makes OpenCode different here?

OpenCode is open and model-agnostic, so you have flexibility over the underlying model. NoClick handles running it and connecting your apps as tools.

How do I give OpenCode tools?

Connect an integration node to the agent's tools handle and choose the operations to allow. Each becomes a tool the agent can call.

Do I manage any infrastructure?

No. NoClick runs the OpenCode harness in a hosted sandbox and resolves credentials for the apps you connect.

Can it combine several apps?

Yes. Add as many integrations as you need and the agent can use them together in one run.

Connect OpenCode to Reducto

Give an AI agent Reducto as a tool and it can read documents for itself instead of guessing at their contents. It can upload a file, parse it into structured text, extract specific fields, classify the document type, or split a multi-document bundle into individual records, calling each operation as it works through a task. That turns a stack of unreadable PDFs into something the agent can actually reason over and act on.

Loading preview…

Opens a workflow with 17 tools ready to use.

What happens next

Set up in minutes

The open button drops you into a guided setup. It asks exactly this, nothing else:

Choose where it runs
On your computer through your own OpenCode, or hosted in the cloud. The rest of setup adapts to your choice:
Pick what it can do in Reducto
A preset of real Reducto operations. Each one becomes a tool the agent can call, and it can't touch anything outside the list.
Connect Reducto
One sign-in. The agent acts through your account, scoped to the operations you picked.
Add your personal MCP link
The last step mints a private MCP URL for this agent and walks you through exactly this, with your real link filled in. The page flips to Connected the moment your OpenCode first calls in. opencode mcp add only saves the config. OpenCode connects when it starts — run opencode, or restart a running one.
1. Run this in your terminal
$opencode mcp add
2. Choose Remote and paste your server URL
https://mcp.noclick.app/s/<your-link>
3. Choose No when asked about OAuth authentication — the link itself is the key
<your-link> is your personal server URL — setup mints it for you.

Exact capabilities

Tools OpenCode gets

Pick the operations you want and each becomes a tool the agent can call directly while it works.

Reducto

17 tools

Upload Document

Upload a file by URL to Reducto storage; returns a reducto:// id reusable as document URL.

Parse Document

Convert a document into layout-aware structured JSON/markdown (synchronous).

Parse Document (Async)

Enqueue a parse job and return a job_id immediately (asynchronous).

Extract Fields

Pull specific structured fields from a document using a JSON schema (synchronous).

Extract Fields (Async)

Asynchronous schema-based field extraction; returns a job_id.

Split Document

Divide a multi-document file into labeled sections (synchronous).

Split Document (Async)

Asynchronous document splitting; returns a job_id.

Classify Document

Categorize a document into one of a provided set of document types/labels.

Edit Document

Programmatically modify a PDF/DOCX - fill forms, write field values, redact (synchronous).

Edit Document (Async)

Asynchronous document editing / form write-back; returns a job_id.

Run Pipeline

Run a composed multi-step pipeline (split -> parse -> extract) in one call (synchronous).

Run Pipeline (Async)

Asynchronous pipeline execution; returns a job_id.

Get Job

Retrieve status and results of an async job.

List Jobs

List async jobs for the account with cursor-based pagination.

Cancel Job

Cancel a running or queued async job.

Configure Webhook

Get the Svix portal URL where webhook delivery endpoints are managed.

Get API Version

Return the running Reducto API version string.

Starting points

What you can build

When a Reducto job completes, pick up the parsed output and write the extracted fields straight into your database or a spreadsheet.

Upload each incoming invoice, extract the vendor, total, and due date, then route it into an approval step automatically.

Parse a signed contract into clean markdown and hand it to an AI step that summarizes the key terms.

Classify inbound documents so purchase orders, resumes, and receipts each get sent down their own path.

Split a scanned batch file into individual documents and process every one as its own record.

Run a saved Reducto pipeline on a new upload as an async job, then poll Get Job until the results are ready to use.

Meet the runner

About OpenCode

OpenCode is an open, model-agnostic command-line coding agent. In NoClick it runs hosted and gains your apps as tools, so it can act on real systems rather than just edit files. Wire an integration into the agent and OpenCode can use that app’s operations directly while it works. It is a flexible choice when you want an open agent with broad model support and real tool access.

Open and model-agnostic

Flexible across many underlying models

Good general-purpose tool use

Lightweight to point at a focused task

Good to know