Menu
Mattering Automations connector

A Replicate MCP that knows every prediction is a paid job

Connect one API token and thousands of open and official ML models become workflow steps for visual automations and AI agents: search the catalog, run predictions, poll results, fine-tune. Every create node says it bills compute time, output URLs say they expire in an hour, and training is flagged like a purchase button.

22 ready-made nodes One credential to connect Works with Claude, ChatGPT, and Matter

What the Replicate MCP connector does

The Replicate connector for Mattering Automations is 22 nodes across the HTTP API: predictions (create by pinned version, by official model, or on one of your deployments, plus get, list, and cancel), fine-tuning trainings (create, get, list, and cancel), model discovery (list models, get a model, list and get versions, curated collections, and a search node spanning models, collections, and docs), deployments (list and get), the hardware SKU list, the authenticated account, and the default webhook signing secret.

Every node speaks MCP, the open protocol for connecting AI assistants to tools, so Claude, ChatGPT, and any MCP-capable assistant can use them, alongside Matter, the AI assistant built into the platform. An assistant can find the right model for a job, read its exact input schema, check what a recent run cost in compute time, and kick off a generation, without anyone opening the Replicate dashboard.

Because Mattering is a work platform rather than middleware, model output lands somewhere useful by default: a generated image can attach to a record in a Mattering database with a review task in Mattering Productivity, and a scheduled sweep of recent predictions can reconcile run history into the same canvas as the rest of the work.

The sharp edges are modeled, not hidden. Predictions are asynchronous: create nodes return a prediction id with status starting, not the finished output, and Replicate: Get Prediction is where results arrive, with an optional bounded wait on the create for fast models. Replicate has no free API tier, so every run bills compute time, and Replicate: Create Training (Async) is flagged like a purchase button. File outputs are HTTPS URLs on replicate.delivery that expire after one hour, so workflows copy what they want to keep, promptly.

One connection, three surfaces

  • Visual automations. Drag Replicate nodes onto the canvas and wire them to triggers, conditions, and other apps.
  • AI agents, yours or ours. These nodes speak MCP, the open protocol, so Claude, ChatGPT, and any MCP-capable assistant can use them, and Matter, the agent built into the platform, uses them natively.
  • The whole platform. Combine with native tasks, projects, and other connectors, no middleware in between.

Every Replicate node, ready to drop on the canvas

22 nodes, generated from the connector itself so this list always matches what ships. Expand a category to browse.

Read and query nodes 16

Replicate: Get Account

Fetch the authenticated account behind the API token: type (user or organization), username, display name, and GitHub URL. Takes no parameters and bills nothing, so it doubles as the credential health check for the connector.

Replicate: Get Collection

Fetch one curated collection by slug, including its full description and the member models (each with owner, name, and latest_version). Note the models array can make this a large response for big collections.

Replicate: Get Default Webhook Secret

Fetch your account's default webhook signing secret (the key used to verify that webhook deliveries really came from Replicate). CAUTION: the secret value lands in this run's execution record; only use this node in automations whose run history you treat as sensitive, and rotate the secret on replicate.com if it leaks.

Replicate: Get Deployment

Fetch one deployment by owner and name: its current release's model, pinned version, hardware SKU, and min/max instance counts. Run it with Replicate: Create Deployment Prediction.

Replicate: Get Model

Fetch one model by owner and name: description, visibility, run count, links, a default example prediction, and latest_version (whose id feeds Create Prediction and whose openapi_schema documents the model's exact input fields).

Replicate: Get Model Version

Fetch one model version, including its openapi_schema: the authoritative spec of the model's input fields (names, types, defaults, constraints) and output shape. Read this before building a Create Prediction input object. The schema can be large; pull just the paths you need downstream.

Replicate: Get Prediction

Fetch one prediction by id: status (starting, processing, succeeded, failed, or canceled), the finished output, error, logs, and compute-time metrics. This is the poll half of the async pattern: loop with a Delay until status is succeeded or failed, then read data.output. Output shape is model-dependent (a string, an array, or an object); File outputs come back as HTTPS URLs on replicate.delivery, never base64 - but those URLs EXPIRE AFTER ONE HOUR, so copy anything you want to keep in a downstream step promptly. data_removed turns true once Replicate purges the run's input/output data.

Replicate: Get Training

Fetch one training job by id: status (starting, processing, succeeded, failed, or canceled), logs, metrics, and on success the output, including the new trained version pushed to your destination model. Poll this after Create Training; fine-tunes commonly run for many minutes.

Replicate: List Collections

List Replicate's curated model collections (super resolution, text to image, speech, and so on): name, slug, and description. Feed a slug into Replicate: Get Collection for the member models. Paginated: follow data.next.

Replicate: List Deployments

List your account's deployments (dedicated model capacity), each with its current release: the model, pinned version, and hardware/instance configuration. Paginated: follow data.next.

Replicate: List Hardware

List the hardware SKUs available for running models on Replicate (CPU and GPU tiers). The sku values are what deployment configurations reference; per-second pricing for each tier is on replicate.com/pricing. Returns a plain JSON array.

Replicate: List Model Versions

List a model's versions, newest first. Each version id is what you pin in Replicate: Create Prediction (and what a training runs against). Paginated: follow data.next.

Replicate: List Models

List public models on Replicate, newest-versioned first by default. Each entry carries owner, name, description, run count, and latest_version. The catalog is huge: for finding a specific capability, Replicate: Search is the better node. Paginated: follow data.next.

Replicate: List Predictions

List your account's recent predictions (API and web runs), newest first, optionally filtered by creation time. Each entry carries id, model, status, and timing; fetch a specific run's full output with Replicate: Get Prediction. Paginated: follow data.next for the next page.

Replicate: List Trainings

List your account's training jobs, newest first, each with id, model, status, and timing. Fetch a specific job's full detail with Replicate: Get Training. Paginated: follow data.next.

Replicate: Search

Search Replicate for models, collections, and docs matching a text query. Model results carry the standard model fields plus a metadata object with a generated_description, tags, and a relevance score. Use it to find the right model slug to feed a Create Prediction node.

Action nodes 6

Replicate: Cancel Prediction

Cancel a running prediction by id (a cost brake for a run that is taking too long). The compute time already used still bills. Success returns an empty response; confirm with Replicate: Get Prediction (status becomes canceled).

Replicate: Cancel Training

Cancel a running training job by id: the cost brake for a fine-tune. Compute time already used still bills. Confirm with Replicate: Get Training (status becomes canceled).

Replicate: Create Deployment Prediction (Async)

Run a prediction on one of YOUR deployments (dedicated capacity you configured on replicate.com), using the deployment's currently configured model version and hardware. Prediction runs are asynchronous: this node returns a prediction id and a status (usually 'starting') immediately, NOT the finished output. Wire a Delay (or a polling loop) and then a Replicate: Get Prediction node to fetch the output once status is 'succeeded'. Optionally set 'wait' to hold this request open up to 60 seconds and skip the poll for fast models. Deployments also bill for instance uptime per your min/max instance settings. Replicate has no free API tier: every run bills your account by the compute time it uses (some official models bill per output or per token instead). File outputs come back as HTTPS URLs on replicate.delivery, never base64 - but those URLs EXPIRE AFTER ONE HOUR, so copy anything you want to keep in a downstream step promptly.

Replicate: Create Official-Model Prediction (Async)

Run an OFFICIAL Replicate model (the always-on, no-version-pinning ones like black-forest-labs/flux-schnell or meta/meta-llama-3-8b-instruct) by owner and name, no version id needed. For community models use Replicate: Create Prediction instead. Prediction runs are asynchronous: this node returns a prediction id and a status (usually 'starting') immediately, NOT the finished output. Wire a Delay (or a polling loop) and then a Replicate: Get Prediction node to fetch the output once status is 'succeeded'. Optionally set 'wait' to hold this request open up to 60 seconds and skip the poll for fast models. Replicate has no free API tier: every run bills your account by the compute time it uses (some official models bill per output or per token instead). File outputs come back as HTTPS URLs on replicate.delivery, never base64 - but those URLs EXPIRE AFTER ONE HOUR, so copy anything you want to keep in a downstream step promptly.

Replicate: Create Prediction (Async)

Run any public or private model on Replicate by version. Prediction runs are asynchronous: this node returns a prediction id and a status (usually 'starting') immediately, NOT the finished output. Wire a Delay (or a polling loop) and then a Replicate: Get Prediction node to fetch the output once status is 'succeeded'. Optionally set 'wait' to hold this request open up to 60 seconds and skip the poll for fast models. Replicate has no free API tier: every run bills your account by the compute time it uses (some official models bill per output or per token instead). File outputs come back as HTTPS URLs on replicate.delivery, never base64 - but those URLs EXPIRE AFTER ONE HOUR, so copy anything you want to keep in a downstream step promptly.

Replicate: Create Training (Async)

Start a fine-tuning job on a trainable model version, pushing the result to a destination model in your account. SPENDS REAL MONEY: trainings are long-running GPU jobs billed by compute time and can cost tens of dollars or more per run, so treat this node like a purchase button. Asynchronous: returns a training id immediately; poll Replicate: Get Training until status is succeeded (or use Cancel Training as the cost brake). The destination model must already exist in your account (create it on replicate.com first; the model-create endpoint is not shipped in this connector).

Connecting Replicate takes one credential

Replicate issues API tokens from the account settings at replicate.com (the API tokens page). The token is sent as a bearer credential on every request, with no OAuth flow involved. Creating a token is free, but there is no free API tier: any prediction or training the token starts bills the account by compute time, so billing must be set up before anything will run.

1

Sign in at replicate.com, open the API tokens page in your account settings, and create a token.

2

In Mattering Automations, open Connectors, click Add Connector, choose Replicate, and create a credential with that token.

3

Click Test Connection. Mattering calls Replicate's account endpoint, a zero-parameter read that bills nothing, and confirms the token authenticates.

4

All 22 Replicate nodes appear in the canvas palette. Start with the reads: Replicate: Search and Replicate: Get Model are free, while every create node bills compute time from the first run.

Common uses for the Replicate MCP

Model discovery an agent can do

Replicate: Search finds models, collections, and docs matching a text query, Replicate: Get Model returns a model's description, run count, and latest version, and Replicate: Get Model Version exposes the openapi_schema that documents the model's exact input fields, names, types, defaults, and constraints. Replicate: List Collections and Replicate: Get Collection browse the curated sets. All of it is read-only and free, which makes it the safest Replicate surface to hand an assistant.

Run any model, honestly async

Replicate: Create Prediction (Async) runs any public or private model by version and returns a prediction id with status starting, not the finished output. Wire a Delay and Replicate: Get Prediction to collect the result once status is succeeded, or set the optional wait field to hold the create request open up to a server-capped 60 seconds and skip the poll entirely for fast models.

Official models without version pinning

Replicate: Create Official-Model Prediction (Async) runs Replicate's always-on official models by owner and name, with no version id at all. It is the low-friction path for the workhorse models, and the same async rules apply: poll with Replicate: Get Prediction, or use the bounded wait for runs that finish fast.

Dedicated capacity when you have it

Replicate: Create Deployment Prediction (Async) runs a prediction on a deployment you configured on replicate.com, using its pinned model version and hardware. Replicate: List Deployments and Replicate: Get Deployment read the configuration, including hardware SKU and instance counts. Deployments bill instance uptime on top of compute time, so this path is for capacity you have deliberately provisioned.

Fine-tuning behind a deliberate gate

Replicate: Create Training (Async) starts a fine-tune on a trainable model version and pushes the result to a destination model in your account, which must already exist. Trainings are long-running GPU jobs that can cost tens of dollars or more per run, so the node is flagged to be treated like a purchase button: put an approval step or a manual run in front of it, poll with Replicate: Get Training, and keep Replicate: Cancel Training within reach.

Run history and cost brakes

Replicate: List Predictions and Replicate: List Trainings sweep recent runs with status and timing, so a scheduled check can spot the stuck and the failed. Replicate: Cancel Prediction stops a run that is taking too long, with the honest caveat that compute time already used still bills, and the create prediction nodes accept a Cancel-After duration as an automatic cost cap set before the run starts.

Example: A prompt becomes a generated image, stored before the URL expires, with a review task attached

Built on the Automations canvas in a few minutes, or described in plain language to Matter and built for you.

1

Trigger: a schedule or form submission delivers a prompt and the record it belongs to.

2

Replicate: Create Official-Model Prediction (Async) runs an official image model by owner and name, with the wait field set so fast runs come back finished in the same call.

3

A Delay and Replicate: Get Prediction loop covers anything still starting or processing, re-checking until status is succeeded or failed.

4

The output arrives as an HTTPS URL on replicate.delivery that expires after one hour, so the next step copies the file somewhere durable immediately.

5

The stored image lands on its record in a Mattering database, and a review task opens in Mattering Productivity with the result attached.

6

If status comes back failed instead, the error and logs from Replicate: Get Prediction route into the task, so a person sees exactly why.

Replicate MCP questions, answered

What Replicate operations are supported?

22 nodes on the HTTP API: predictions (create by version, by official model, or on a deployment, plus get, list, and cancel), trainings (create, get, list, cancel), models and versions (list and get), curated collections (list and get), search across models, collections, and docs, deployments (list and get), the hardware SKU list, the authenticated account, and the default webhook signing secret. Deliberately not shipped: the Files API, since upload needs a multipart binary POST the canvas cannot produce and file inputs work by HTTPS URL anyway; model and deployment lifecycle management, since creating or resizing a deployment provisions standing billable GPU instances; and version deletes.

Does this work with Claude, ChatGPT, or other AI assistants?

Yes. Mattering exposes these nodes over MCP, an open protocol for connecting AI assistants to tools, so any MCP-capable assistant, including Claude and ChatGPT, can connect to your workspace and use them. Matter, the assistant built into the platform, uses the same nodes natively.

Why does Create Prediction return no output?

Because predictions are jobs. Replicate: Create Prediction (Async) returns a prediction id and a status, usually starting, in under a second, and the model runs after that. The canvas pattern is create, then a Delay, then Replicate: Get Prediction, looped until status is succeeded, failed, or canceled, then read the output. For fast models, set the optional wait field on the create node: Replicate holds the request open up to 60 seconds, a cap the server enforces, and returns the finished prediction if it completes in time. If it does not, you get the normal starting state and poll as usual, so the worst case is the async behavior you would have had anyway.

Can this connector spend real money?

Yes, by design, and it says so on the nodes. Replicate has no free API tier: every prediction bills the account by the compute time it uses, some official models bill per output or per token instead, and deployments additionally bill instance uptime. Replicate: Create Training (Async) is the big-ticket node, flagged to be treated like a purchase button because fine-tunes can cost tens of dollars or more per run. The brakes are real but partial: Replicate: Cancel Prediction and Replicate: Cancel Training stop a run, but compute time already used still bills, and the create prediction nodes accept a Cancel-After duration as an automatic cap you set before the run starts.

Why did my output URL stop working after an hour?

That is Replicate's documented behavior, not a bug. File outputs are served from replicate.delivery and those URLs expire after one hour; Replicate's own docs say to save a copy of any files you want to keep using. Build the copy step into the workflow, right after the poll succeeds, rather than storing the URL itself. Separately, once Replicate purges a run's input and output data, the prediction's data_removed field turns true and the data is gone for good.

Can a finished prediction trigger a workflow?

Not as a trigger node in this connector: there is no inbound Replicate trigger. The honest pattern today is the bounded wait on the create nodes for fast models, a Delay plus Replicate: Get Prediction loop for everything else, and a scheduled Replicate: List Predictions sweep for reconciling history. Replicate: Get Default Webhook Secret exists so you can verify webhook deliveries to an endpoint you operate yourself, but the connector does not receive events.

How do file inputs and outputs work?

Inputs travel as HTTPS URLs inside the input object: point the model at a publicly reachable URL, which is the form Replicate's docs prefer for anything over 256 KB, with data URLs possible for tiny files. There is no multipart upload in this connector, since the Files API is deliberately omitted. Outputs come back the same way: file outputs are HTTPS URLs on replicate.delivery, never base64, with the one-hour expiry to plan around. Non-file output is inline and model-shaped: a string, an array, or an object, depending on the model.

Which create node should I use?

There are three, split by how the model is addressed. Replicate: Create Prediction (Async) runs any public or private model and accepts the version in three forms: owner/model for the latest version, owner/model:versionid, or a bare 64-character version id. Replicate: Create Official-Model Prediction (Async) runs Replicate's always-on official models by owner and name with no version field; the docs are explicit that this path is only for official models. Replicate: Create Deployment Prediction (Async) runs on a deployment you configured on replicate.com, using whatever version and hardware the deployment pins.

22 nodes waiting on the canvas

Put Replicate to work inside your workspace

Connect once, then use every node in visual automations and AI agent workflows across the Mattering platform.

All product names, logos, and brands are property of their respective owners and are used for identification purposes only. Use of these names, logos, and brands does not imply endorsement or affiliation. Replicate is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products