Menu

Mattering Automations Render integration

Connect Render to Mattering Automations: services, deploys, custom domains, environment variables and env groups, jobs, Postgres, Key Value, disks, and logs as workflow steps, authenticated with a Render API key.

The Mattering Automations Render integration adds Render to your automation canvas: list, create, update, suspend, resume, restart, and delete services, trigger, cancel, and roll back deploys, manage custom domains and their DNS verification, set environment variables directly or through shared env groups, run one-off jobs and on-demand cron runs, provision and recover Postgres, read Key Value connection details, manage persistent disks and registry credentials, and query logs, service events, notification settings, and platform maintenance windows.

Render's REST API lives under api.render.com/v1 and authenticates with a single API key sent as an Authorization Bearer header. List endpoints use cursor pagination with a distinctive wrapper shape, and rate limits are documented per endpoint family; this guide covers both because they are the two things most likely to surprise you.

Setup takes a few minutes: create an API key in Render, attach it as a credential in Mattering, and run one read-only node to confirm it works. This guide walks through each step and ends with the full node reference.

Before you start

  • A Render account with the services or databases you want to automate. You can create an API key from Account Settings on any plan.
  • A Mattering workspace with access to the Automations app.
  • Access to the Render dashboard as the user whose infrastructure you want to reach. The API key you create is user-scoped, not workspace-scoped: Render's documentation states that an API key provides access to all workspaces you belong to, so create it under the account whose reach you actually want.

Create a Render API key

Mattering authenticates to Render with an API key, sent as an Authorization Bearer header. You create it from your account settings in the Render dashboard, not from an individual service or workspace.

Sign in to the Render dashboard and open Account Settings.
Find the API Keys section and create a new API key. Give it a name that says where it will be used, such as Mattering Automations.
Copy the key value.
Copy the key as soon as it is created and store it somewhere safe until it is pasted into Mattering. Treat it like a password: it is user-scoped, so it reaches every workspace your Render user belongs to, and there is no narrower scope to fall back on.
There is no plan gate on key creation: you can create an API key from Account Settings on any Render plan, including the free one, so you can try the whole integration before paying Render anything.

Connect Render to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Render from the list.
Click Create new credential, paste your Render API key, and save.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection. The connector calls Render's workspaces endpoint with your key, so a passing test means the key authenticates against the live API.
Click Connect. All 60 Render nodes appear in your canvas palette, 29 read nodes and 31 action nodes.

Verify it works

Open any automation canvas and check the palette: a Render section should list the read and action nodes. Drop Render: List Workspaces onto the canvas and run a test step. It takes no parameters and is a safe read, so a successful response lists each workspace the key can reach with its id, name, and type. That id is the ownerId that Render: Create Service and Render: Create Postgres Instance require, which is why most flows start here.

Then add Render: List Services and run it. Render returns list results as an array of wrapper objects, each holding the entity and a pagination cursor side by side, so the first service id lives at data[0].service.id rather than data[0].id. Copy a service id from the result and feed it to Render: Get Service to confirm reads against a specific resource.

Node reference

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

Read and query nodes 29

Render: Get Custom Domain

render_get_custom_domain

Fetch one custom domain by id or name: verification status, domain type and redirect pairing.

Render: Get Deploy

render_get_deploy

Fetch one deploy: commit or image reference, status, trigger and timestamps. Poll this after triggering a deploy to watch it go live.

Render: Get Disk

render_get_disk

Fetch one persistent disk: size, mount path and attached service.

Render: Get Env Group

render_get_env_group

Fetch one environment group including its env vars, secret files and linked services. WARNING: the response contains each variable's plaintext value, and node outputs are stored in automation execution records.

Render: Get Event

render_get_event

Fetch one event by id with its full details payload.

Render: Get Job

render_get_job

Fetch one one-off job: start command, plan, status and timestamps. Poll this after Render: Create Job to watch it finish.

Render: Get Key Value Connection Info

render_get_key_value_connection_info

Fetch a Key Value instance's connection details: internal and external connection strings and a ready CLI command. WARNING: the response contains LIVE credentials (password and connection strings) and node outputs are stored in automation execution records, so running this copies the credentials into execution history.

Render: Get Key Value Instance

render_get_key_value

Fetch one Key Value instance: plan, region, status, eviction policy, persistence mode and IP allow list.

Render: Get Maintenance Run

render_get_maintenance

Fetch one maintenance run: state, scheduled time, deadline and the affected resource.

Render: Get Notification Settings

render_get_notification_settings

Fetch a workspace's notification settings: email and Slack toggles, preview-environment notifications and which events notify (none, failure or all).

Render: Get Postgres Connection Info

render_get_postgres_connection_info

Fetch a Postgres instance's connection details: password, internal and external connection strings and a ready psql command. WARNING: the response contains LIVE credentials (password and connection strings) and node outputs are stored in automation execution records, so running this copies the credentials into execution history.

Render: Get Postgres Instance

render_get_postgres

Fetch one Postgres instance: version, plan, disk size, status, IP allow list and dashboard URL. Connection strings live on the separate connection-info node.

Render: Get Postgres Recovery Info

render_get_postgres_recovery_info

Check a Postgres instance's point-in-time recovery status: AVAILABLE, BACKUP_NOT_READY or NOT_AVAILABLE, plus the start of the recovery window.

Render: Get Service

render_get_service

Fetch one service by id: type, repo, branch, plan, region, URL, suspension state and the type-specific serviceDetails block.

Render: Get Workspace

render_get_owner

Fetch one workspace (owner) by id: name, email and type. Use the id as the ownerId when creating services or databases.

Render: List Custom Domains

render_list_custom_domains

List a service's custom domains with type (apex or subdomain), verification status and any redirect pairing.

Render: List Deploys

render_list_deploys

List a service's deploys newest first: commit, status (live, build_failed, canceled...), trigger and timestamps. The first live deploy's id is what rollback needs.

Render: List Disks

render_list_disks

List persistent disks with size, mount path and the service each disk is attached to.

Render: List Env Groups

render_list_env_groups

List environment groups (shared sets of env vars and secret files) with the services each group is linked to.

Render: List Env Vars

render_list_env_vars

List the environment variables set directly on a service (variables from linked environment groups are NOT included). WARNING: the response contains each variable's plaintext value, and node outputs are stored in automation execution records.

Render: List Jobs

render_list_jobs

List one-off jobs run against a service with their start command, status and timestamps.

Render: List Key Value Instances

render_list_key_value

List Render Key Value instances (Redis-compatible, Valkey backed) with plan, region, status, eviction policy and persistence mode. Supersedes the deprecated Redis endpoints.

Render: List Logs

render_list_logs

Query logs across services, cron jobs, jobs and Postgres instances with text, level, status-code and path filters (wildcards supported). Returns up to 100 lines plus hasMore/nextStartTime for continuing. Rate limited to 30 log reads per minute.

Render: List Maintenance Runs

render_list_maintenance

List scheduled and past platform maintenance runs for services, Postgres and Key Value instances so automations can anticipate maintenance windows.

Render: List Postgres Instances

render_list_postgres

List Render Postgres instances with version, plan, disk size, region, status and suspension state.

Render: List Registry Credentials

render_list_registry_credentials

List container registry credentials (Docker Hub, GitHub, GitLab, Google Artifact Registry, AWS ECR) available for image-backed services. Auth tokens are never returned.

Render: List Service Events

render_list_events

List a service's activity events (build_started, deploy_ended, suspension changes...) newest first. Defaults to the last hour; widen with startTime/endTime. Useful as a polling trigger source for deploy outcomes.

Render: List Services

render_list_services

List services (web services, static sites, private services, background workers and cron jobs) with repo, branch, region, plan, URL and suspension state. Filter by name, type, region, workspace or timestamps; page with cursor/limit.

Render: List Workspaces

render_list_owners

List the workspaces (owners) the API key can access, with each workspace's id (the ownerId that service and Postgres creation require), name, email and type (user or team). A Render API key is user-scoped and reaches every workspace its user belongs to.

Action nodes 31

Render: Add Custom Domain

render_add_custom_domain

Attach a custom domain to a service. Adding an apex domain also creates its www subdomain (and vice versa) as a redirect. DNS must then be pointed at Render and verified. Rate limited to 50 custom-domain calls per hour.

Render: Add Disk

render_add_disk

Attach a new persistent disk to a service. Disks are BILLABLE per GB per month and attaching one redeploys the service (and removes its ability to scale to multiple instances).

Render: Cancel Deploy

render_cancel_deploy

Cancel an in-progress deploy. The previously live deploy stays live. Not supported for cron jobs.

Render: Cancel Job

render_cancel_job

Cancel a running one-off job. Returns the job with its updated status.

Render: Create Env Group

render_create_env_group

Create an environment group of shared env vars (and optional secret files) and optionally link it to services in the same call.

Render: Create Job

render_create_job

Run a one-off job (an arbitrary command) using a service's environment and most recent build. The job runs on billable compute (per-second on the chosen plan). Rate limited to 100 job creations per minute.

Render: Create Postgres Instance

render_create_postgres

Create a Render Postgres instance. Paid plans begin billing immediately; the free plan allows one instance per workspace with 1 GB storage that EXPIRES 30 days after creation (14-day grace period before deletion).

Render: Create Registry Credential

render_create_registry_credential

Store a container registry credential for pulling private images into image-backed services.

Render: Create Service

render_create_service

Create a service (web service, static site, private service, background worker or cron job) from a Git repo or a container image and start its first build. Paid instance types begin billing immediately; the first deploy consumes pipeline minutes. Rate limited to 20 service creations per hour.

Render: Delete Custom Domain

render_delete_custom_domain

Detach a custom domain from a service. The domain stops routing to the service immediately; re-adding it requires DNS re-verification.

Render: Delete Env Var

render_delete_env_var

Delete one environment variable from a service. The value is gone unless you captured it first (Render: List Env Vars). Takes effect on the next deploy.

Render: Delete Postgres Instance

render_delete_postgres

Permanently delete a Postgres instance AND ITS DATA. IRREVERSIBLE outside the point-in-time recovery window.

Render: Delete Registry Credential

render_delete_registry_credential

Delete a registry credential. Services still configured to use it will fail to pull their image on the next deploy.

Render: Delete Service

render_delete_service

Permanently delete a service, its deploys and its custom domain attachments. IRREVERSIBLE: the service and its history cannot be recovered.

Render: Link Env Group To Service

render_link_env_group

Link an environment group to a service so the service receives all of the group's env vars and secret files. Reversible with Render: Unlink Env Group From Service.

Render: Replace All Env Vars

render_update_env_vars

REPLACE the full set of environment variables on a service: any existing variable not present in the submitted array is DELETED. To change one variable without touching the rest use Render: Set Env Var instead. Changes take effect on the next deploy.

Render: Restart Service

render_restart_service

Restart a service's running instances without rebuilding. Brief downtime while instances cycle; no pipeline minutes consumed.

Render: Resume Postgres Instance

render_resume_postgres

Resume a suspended Postgres instance so it accepts connections again.

Render: Resume Service

render_resume_service

Resume a suspended service so it deploys and serves traffic again. Rate limited to 10 per minute per service.

Render: Rollback Deploy

render_rollback_deploy

Roll a service back to a previous deploy by id. Rollback does NOT disable autodeploy: the next commit on the connected branch will deploy over the rollback unless autoDeploy is set to no first (Render: Update Service).

Render: Run Cron Job Now

render_run_cron_job

Trigger an immediate run of a cron job service outside its schedule. CANCELS any currently active run of the same cron job first. The run consumes billable compute like a scheduled run.

Render: Set Env Var

render_set_env_var

Add or update ONE environment variable on a service without touching the others. Provide value, or set generateValue true to have Render generate one. Applies only to variables set directly on the service, not linked environment groups. Takes effect on the next deploy.

Render: Suspend Postgres Instance

render_suspend_postgres

Suspend a Postgres instance: it stops accepting connections until resumed. Data is retained. Reversible with Render: Resume Postgres Instance.

Render: Suspend Service

render_suspend_service

Suspend a running service: it stops serving traffic and stops accruing instance charges until resumed. Reversible with Render: Resume Service. Rate limited to 10 per minute per service.

Render: Trigger Deploy

render_trigger_deploy

Trigger a new deploy of a service - the latest commit by default, or a specific commit or image. This runs a real build that consumes the workspace's monthly pipeline minutes; beyond the included allowance Render bills or suspends. Render also rate-limits deploy calls to 10 per minute per service.

Render: Trigger Postgres Recovery

render_recover_postgres

Restore a Postgres instance to a point in time. Render creates a NEW instance from the recovery point (the source is untouched); the new instance bills on its plan. Check Render: Get Postgres Recovery Info first.

Render: Unlink Env Group From Service

render_unlink_env_group

Unlink an environment group from a service: the service loses access to the group's env vars and secret files. The group itself is untouched and can be re-linked.

Render: Update Disk

render_update_disk

Update a persistent disk's name, size or mount path. Size can only GROW (growing raises the monthly charge); it can never shrink. Changes trigger a service redeploy.

Render: Update Notification Settings

render_update_notification_settings

Update a workspace's notification settings. Only the fields you send change.

Render: Update Service

render_update_service

Update a service's settings (name, branch, auto-deploy, root directory, build filter, type-specific details). Only the fields you send change. Rate limited to 10 per minute per service.

Render: Verify Custom Domain DNS

render_verify_custom_domain

Trigger a re-check of a custom domain's DNS configuration (returns 202; poll Render: Get Custom Domain for the resulting verificationStatus). Harmless to repeat; counts against the 50-per-hour custom-domain rate limit.

Using the integration

On the automation canvas

Render nodes chain with every other node: a failed deploy can pull its own logs, an AI step can summarize them, a rollback can run automatically, and a task can land in Mattering Productivity with the evidence attached. Deploy, delete, and job nodes act on live infrastructure and consume real resources, so put a condition or an approval step in front of the ones you would not want fired by accident. Render: Trigger Deploy in particular runs a real build that consumes your workspace's monthly pipeline minutes.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and Matter can list services, read logs, set variables, and trigger deploys through the same nodes your workflows use. Render separately ships its own official MCP server for driving Render from AI development tools; these nodes are the automation-canvas surface, and the two coexist without conflict.

Resolving Render ids

Most nodes take ids rather than names. Render: List Workspaces returns each workspace's id, the ownerId that creation nodes require. Render: List Services filters by name, type, region, or workspace to find a service id, and Render: List Deploys returns a service's deploys newest first, where the first deploy with status live is the id a rollback needs.

Paging through lists

List nodes accept a limit from 1 to 100, defaulting to 20, and a cursor. Responses arrive as an array of wrapper objects with the entity and its cursor side by side, so read entities from paths like data[0].service and page by passing the last item's cursor back into the same node. Filters that accept multiple values, such as several service names, take a JSON array and are sent as repeated query parameters.

Handling secrets

Render: Get Postgres Connection Info and Render: Get Key Value Connection Info return live passwords and connection strings, and Render: List Env Vars and Render: Get Env Group return plaintext variable values. Node outputs are stored in automation execution records, so run these nodes only where a workflow genuinely needs the value, and never forward their output into a logging, message, or notification node.

Changing configuration safely

Render: Set Env Var changes one variable and leaves the rest alone, which makes it the safe default. Render: Replace All Env Vars is a full replacement: any variable missing from the submitted array is deleted, so reserve it for workflows that own the complete set. Either way, environment variable changes take effect on the service's next deploy, and shared configuration is better handled with Render: Create Env Group and Render: Link Env Group To Service.

Troubleshooting

Every node returns a 401 unauthorized error
The credential is not a valid Render API key. Confirm you pasted an API key created from Account Settings in the Render dashboard, not some other token, and that it has not been revoked. Create a fresh key, update the credential on the connector, and click Test Connection again: it calls Render's workspaces endpoint, so a passing test proves the key authenticates.
A create node fails because ownerId is missing or not accepted
Render creation endpoints for services, Postgres, env groups, and registry credentials require an explicit ownerId naming the target workspace, because the API key itself is user-scoped and reaches every workspace you belong to. Run Render: List Workspaces and use the id of the workspace you intend to create in.
Requests start returning HTTP 429
You hit a documented rate limit. Render allows 400 GET requests per minute in general and 30 other requests per minute, with tighter per-endpoint caps: 20 service creations per hour, 10 deploy, suspend, resume, or service update calls per minute per service, 50 custom domain calls per hour, 100 job creations per minute, and 30 log reads per minute. Responses include Ratelimit-Remaining and Ratelimit-Reset headers, so pace loops against those rather than retrying in a tight loop.
List results are wrapper objects instead of a plain list
That is Render's real response shape, preserved so canvas field paths match the API documentation. Each item in a list response holds the entity and a pagination cursor side by side, so read a service from data[0].service and its id from data[0].service.id. To fetch the next page, pass the LAST item's cursor back into the node's cursor field.
An environment variable change did not take effect
Environment variable changes apply on the service's next deploy, not immediately. Chain Render: Trigger Deploy after the change when it needs to land now. Also check where the variable lives: Render: Set Env Var and Render: List Env Vars only touch variables set directly on the service, not variables inherited from a linked environment group, which are managed through the env group nodes.
A rollback was undone by the next push
Rolling back does not disable autodeploy, so the next commit on the connected branch deploys right over the rollback. When a rollback needs to stick, follow Render: Rollback Deploy with Render: Update Service setting autoDeploy to no, and turn it back on once the branch is fixed.
A free web service responds very slowly after sitting idle
Render spins free web services down after 15 minutes without traffic, and the next request triggers a cold start that can take up to a minute. That is documented free tier behavior, not a connector problem. Free services also share 750 free instance hours per workspace per month; upgrade the service's plan if it needs to stay warm.
A free Postgres database stopped accepting connections after a month
Render's free Postgres instances expire 30 days after creation, with a 14 day grace period before the instance is deleted. Upgrade it to a paid plan to keep it, or treat free databases as disposable in your workflows. Render: Get Postgres Instance reports the instance's status, so a scheduled check can warn you before the deadline instead of after it.
There are no Redis nodes in the palette
Render's Redis API endpoints are deprecated, replaced by Key Value, so this integration ships Key Value nodes only: Render: List Key Value Instances, Render: Get Key Value Instance, and Render: Get Key Value Connection Info. They cover Render's current Redis-compatible product, and the connection info node returns the connection string a Redis client needs.

Render 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