Menu

Mattering Automations Replicate integration

Connect Replicate to Mattering Automations: run thousands of open and official ML models as async predictions, fine-tune with trainings, and browse models, collections, deployments, and hardware as workflow steps, authenticated with a Replicate API token.

The Mattering Automations Replicate integration adds Replicate to your automation canvas: run any of thousands of open and official ML models as predictions, poll for results, start and monitor fine-tuning trainings, run on your own deployments, and browse models, versions, curated collections, and the hardware SKU list.

Setup takes a few minutes: create an API token in your Replicate account settings, attach it as a credential in Mattering, and test the connection. This guide walks through each step and ends with the full node reference.

Two facts shape everything here. First, Replicate has no free API tier: every prediction and training bills the account by compute time, and Replicate: Create Training (Async) is flagged to be treated like a purchase button. Second, runs are asynchronous: the create nodes return a prediction id with status starting, not output, and Replicate: Get Prediction is where results actually arrive. Verify the integration with read nodes only; they are free.

Before you start

  • A Replicate account with billing set up. There is no free API tier: creating a token is free, but every prediction or training run bills compute time, so runs need a payment method behind them.
  • An API token, created from the API tokens page in your Replicate account settings.
  • A Mattering workspace with access to the Automations app.
  • For models that take file inputs: the files hosted at publicly reachable HTTPS URLs, since inputs travel by URL.

Create a Replicate API token

Mattering authenticates to Replicate with an API token, sent as a bearer credential on every request; there is no OAuth flow. Tokens are created in your Replicate account settings.

Sign in at replicate.com and open the API tokens page in your account settings (replicate.com/account/api-tokens).
Create a token and copy it.
Confirm the account has billing set up: Replicate has no free API tier, so prediction and training runs will not get far without a payment method on the account.
This token can spend money. Any prediction or training it starts bills the account by compute time, with no free tier to absorb mistakes, so treat it like a payment credential: keep it out of shared documents, and rotate it from the same account settings page if it ever leaks.

Connect Replicate to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Replicate from the list.
Click Create new credential, paste your API token, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection: Mattering calls Replicate's account endpoint, a zero-parameter read that bills nothing, and confirms the token authenticates.
Click Connect. All 22 Replicate nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: a Replicate section should list the query and action nodes. Drop Replicate: Get Account onto the canvas and run a test step. It takes no parameters, bills nothing, and a successful response returns the account behind the token: its type (user or organization), username, and display name. This is the same call Test Connection makes, so it proves the base URL, auth header, and credential end to end.

To confirm the wider surface, run Replicate: Search with a text query, or Replicate: List Collections and feed a slug into Replicate: Get Collection. Everything in the verify path is a free read. The first node that costs money is a create, so save Replicate: Create Prediction (Async) for when you mean it, and start with a cheap official model when you do.

Node reference

22 nodes, generated from the connector itself so this reference always matches what ships.

Read and query nodes 16

Replicate: Get Account

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

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

replicate_get_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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

replicate_create_deployment_prediction

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)

replicate_create_model_prediction

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)

replicate_create_prediction

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)

replicate_create_training

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).

Using the integration

On the automation canvas

Replicate nodes chain with every other node: a prompt from a form can become a generated image whose file is copied somewhere durable before its URL expires, a scheduled Replicate: List Predictions sweep can reconcile run history into a Mattering database, and a finished output can open a review task in Mattering Productivity with the result attached.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and Matter can search for models, read input schemas, check run status, and start predictions through the same nodes your workflows use. The discovery surface, Replicate: Search, Replicate: Get Model, Replicate: Get Model Version, and the collection nodes, is read-only and free, which makes it the safest Replicate surface to hand an agent; the create nodes bill compute time, so gate them the way you would any spend.

The async prediction pattern

Replicate: Create Prediction (Async), Replicate: Create Official-Model Prediction (Async), and Replicate: Create Deployment Prediction (Async) all return a prediction id and a status, usually starting, in under a second: no output yet. The canvas pattern is create, then a Delay, then Replicate: Get Prediction, looped until status is succeeded, failed, or canceled, then read data.output. For fast models, set the optional wait field on the create node: Replicate holds the request open up to a server-capped 60 seconds and returns the finished prediction if it completes in time; otherwise you get the normal starting state and poll as usual. Trainings follow the same shape through Replicate: Get Training and commonly run for many minutes. There is no inbound Replicate trigger in this integration, so reacting to finished runs means polling; Replicate: Get Default Webhook Secret exists to verify webhook deliveries to an endpoint you operate yourself, with the caution that the secret value lands in that run's execution record.

The money model

There is no free tier: every prediction bills 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: fine-tunes are long-running GPU jobs that can cost tens of dollars or more per run, so treat it like a purchase button and keep it behind an approval step or a manual run. Replicate: Cancel Prediction and Replicate: Cancel Training are the cost brakes, with the honest caveat that compute time already used still bills, and the create prediction nodes accept a Cancel-After duration (for example 30s or 5m) as an automatic cap set before the run starts. Replicate's documented rate limits are 600 requests per minute on prediction creates and 3000 per minute elsewhere.

Outputs: one-hour URLs, model-shaped data

File outputs come back as HTTPS URLs on replicate.delivery, never base64, and those URLs expire after one hour: copy anything worth keeping in a downstream step promptly, right after the poll succeeds. Non-file output is inline and model-shaped: a string, an array, or an object, depending on the model. Once Replicate purges a run's input and output data, the prediction's data_removed field turns true and the data is gone. File inputs travel the other way as HTTPS URLs inside the input object; Replicate's docs prefer URLs for anything over 256 KB, with data URLs possible for tiny files, and the multipart Files API is deliberately not shipped.

Choosing a create node

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 at all; 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. Before building any input object, read Replicate: Get Model Version: its openapi_schema is the authoritative spec of the model's input fields, defaults, and constraints.

Troubleshooting

Test Connection fails with a 401
The token is invalid, was revoked, or picked up stray whitespace when pasted. Create a fresh token on the API tokens page in your Replicate account settings and update the credential on the connector, then run Test Connection again; the check is a free read, so retrying costs nothing.
A create node succeeded but there is no output
That is the async model working as documented. The create nodes return a prediction id with status starting, not the finished result. Wire a Delay and Replicate: Get Prediction after the create, looped until status is succeeded, failed, or canceled, then read data.output. For fast models, set the wait field on the create node to hold the request open up to 60 seconds and skip the poll.
An output URL that worked earlier now fails
Output URLs on replicate.delivery expire after one hour; Replicate's docs say to save a copy of any files you want to keep using. Fix the workflow so a copy step runs immediately after the poll succeeds, and store the durable copy rather than the URL. If Replicate: Get Prediction shows data_removed as true, Replicate has purged the run's data and the output is no longer recoverable.
A prediction ends in failed
Fetch the run with Replicate: Get Prediction and read data.error and the logs: model errors surface there, not on the create call. If the error points at the input, check it against the model's openapi_schema from Replicate: Get Model Version, which is the authoritative list of field names, types, defaults, and constraints for that exact version.
Requests start failing with 429
Replicate's documented rate limits are 600 requests per minute on prediction creates and 3000 per minute on everything else, and throttled calls return a 429 with a detail message. Slow the loop down: lengthen the Delay between polls, batch discovery reads, and back off before retrying rather than hammering the same call.
A cancel node returned an empty response
That is the documented shape: cancels return an empty response on success. Confirm with the matching get node, Replicate: Get Prediction or Replicate: Get Training, where status becomes canceled. Note the brake is partial by design: compute time the run already used still bills.
Replicate: Create Training (Async) fails on the destination model
The destination model must already exist in your Replicate account before the training starts; the integration does not ship a model-create node. Create the destination model on replicate.com first, then re-run the training with that owner and name. And keep the gate in front of this node regardless: trainings bill like the long-running GPU jobs they are.
A model needs a file input and there is no upload node
File inputs travel as HTTPS URLs inside the input object, so host the file somewhere publicly reachable and pass the URL; Replicate's docs prefer URLs for anything over 256 KB, and tiny files can be data URLs. There is no multipart upload here because the Files API is deliberately omitted: upload requires a binary POST the canvas cannot produce.

Replicate is a trademark of its respective owner. Mattering uses platform names to identify the services these integrations connect to; no endorsement or affiliation is implied.

Start Free Explore our Products