Menu
Mattering Automations connector

A Neon MCP for automations that reach past the database

Connect one Neon API key and projects, branches, compute endpoints, databases, and roles become workflow steps. A pull request can get its own database branch with a ready-to-use connection string, a batch job can warm its compute first and suspend it after, and a credential rotation can run on a schedule instead of a sticky note.

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

What the Neon MCP connector does

The Neon connector for Mattering Automations is 39 nodes across the Neon API v2, the management surface of Neon's serverless Postgres platform: projects with connection URIs, branches with create, update, delete, and set-default, compute endpoints with start, suspend, and restart, per-branch databases and roles including password reset, the operations feed that tracks Neon's asynchronous work, regions, and the consumption metrics family. One API key authenticates all of it.

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 agent can list your projects, fork the default branch copy-on-write, poll the operation until the branch is ready, and hand back a Postgres connection string, without anyone opening the Neon Console.

Neon runs its own official MCP server, hosted at mcp.neon.tech, and it is a genuine option when all you want is an assistant talking to Neon alone. This connector is for the other half of the job, where Neon is one step among many: on the Mattering canvas the same nodes sit next to every other connector and the platform itself, so a pull request webhook can branch the database and then open a review task, a branch delete can wait behind a human approval step, and a consumption sweep can write what it finds into a Mattering database. Use whichever fits, or both.

The safety modeling is stated plainly. Of the 39 nodes, 20 read and 19 act, and five are flagged destructive: the project, branch, compute endpoint, database, and role deletes. Branch deletes are soft by default, with a 7-day recovery grace period documented in Neon's API, but compute endpoint deletes are permanent in a specific way: Neon documents that a compute deleted and added back later gets different connection details, so every connection string naming the old endpoint breaks for good. Some surfaces are deliberately not shipped at all: API key creation and revocation stay in the Neon Console because minting credentials from a credential is self-escalation, and the endpoint that reveals a role's stored password is omitted in favor of the safer password reset. What remains is the surface an automation can hold safely.

One connection, three surfaces

  • Visual automations. Drag Neon 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 Neon node, ready to drop on the canvas

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

Read and query nodes 20

Neon: Get Branch

Fetch one branch: parent, default flag, protected flag, state, and usage counters.

Neon: Get Branch Consumption

Per-BRANCH consumption history for 1 to 100 named projects at hourly, daily, or monthly granularity - the finest-grained cost attribution Neon offers (which branch is burning the compute). Metrics come back as name-value pairs; extra_branches_month and snapshot_storage_bytes_month are NOT supported here (use Neon: Get Project Consumption). Per the API spec this endpoint serves paid usage-based Launch, Scale, Agent, and Enterprise plan accounts; org_id, metrics, and project_ids are required. Rows nest as data.branches[].periods[].consumption[].

Neon: Get Compute Endpoint

Fetch one compute endpoint: host, branch, type, state, autoscaling limits, and scale-to-zero timeout.

Neon: Get Connection URI

Build a ready-to-use Postgres connection string for a database and role. Returns a LIVE credential - the URI embeds the role's password - and the value is stored in automation execution records, so treat downstream use accordingly. Defaults to the project's default branch and its read-write compute; set pooled to true for the -pooler (PgBouncer) host.

Neon: Get Current User

Fetch the authenticated Neon account: id, email, login, plan, and project/branch limits. Works with any API key variant and no parameters - the credential health check to run first in any Neon automation.

Neon: Get Database

Fetch one database on a branch: name, owning role, and timestamps.

Neon: Get Operation

Poll one operation until its status is finished (or failed / error). Statuses: scheduling, running, finished, failed, error, cancelling, cancelled, skipped. Every Neon write node returns the operation IDs to poll here in data.operations[].id.

Neon: Get Project

Fetch one project: region, Postgres version, history retention, and current-period usage totals (compute time, active time, written data, storage).

Neon: Get Project Consumption

Per-project consumption history in the current metric set, at hourly, daily, or monthly granularity. Each timeframe returns the requested metrics as name-value pairs (compute_unit_seconds, root_branch_bytes_month, child_branch_bytes_month, instant_restore_bytes_month, public/private_network_transfer_bytes, extra_branches_month, snapshot_storage_bytes_month). Per the API spec this endpoint serves Launch, Scale, Agent, Business, and Enterprise plan accounts; org_id and metrics are required. Does not wake any compute. Rows nest as data.projects[].periods[].consumption[].

Neon: Get Project Consumption (Legacy Metrics)

Per-project consumption history in the LEGACY metric set: rows of active_time_seconds / compute_time_seconds / written_data_bytes (per-timeframe usage) and synthetic_storage_size_bytes (a storage SIZE snapshot - never sum it across timeframes) at hourly, daily, or monthly granularity. Per the API spec this endpoint serves Scale, Business, and Enterprise plan projects; newer plans use the v2 node. Does not wake any compute. Rows nest as data.projects[].periods[].consumption[].

Neon: Get Role

Fetch one role on a branch: name, protected flag, and timestamps. The password is not included.

Neon: List API Keys

List the account's API keys: name, creation date, creator, and last-used time and address. Key TOKENS are never included - Neon only shows a token once at creation. Read-only audit surface; key creation and revocation stay in the Neon Console. Note: the response is a top-level ARRAY (data[0].id), not an object.

Neon: List Branches

List a project's branches with their IDs, parents, default flag, and state. The branch ID from here feeds the database, role, and compute nodes. NOTE: this lister's cursor lives at data.pagination.next (not .cursor like the other Neon listers).

Neon: List Compute Endpoints

List a project's compute endpoints with their IDs, hosts, branch bindings, types (read_write or read_only), and current state (active, idle...). The endpoint ID from here feeds the start, suspend, restart, update, and delete nodes.

Neon: List Databases

List the databases on a branch with their names and owning roles. Databases are branch-level in Neon: each branch carries its own copy.

Neon: List My Organizations

List the organizations the authenticated account belongs to, with their org IDs and plans. The org_id from here scopes project listing and the consumption-metrics nodes.

Neon: List Operations

List a project's recent operations - the asynchronous work Neon schedules for writes (create_branch, start_compute, suspend_compute...) - newest first, with status and duration. Cursor paginated via data.pagination.cursor. The audit and monitoring view of everything the other action nodes kicked off.

Neon: List Projects

List the projects the API key can access, with their project IDs, regions, and Postgres versions. The project ID from here feeds every other Neon node. Cursor paginated: pass data.pagination.cursor back to get the next batch.

Neon: List Regions

List the regions Neon supports, with the region_id values Create Project accepts. Not all regions are available to all organizations - pass org_id for an accurate list.

Neon: List Roles

List the Postgres roles on a branch. Passwords are not included. Roles are branch-level in Neon: each branch carries its own copy.

Action nodes 19

Neon: Create Branch

Create a branch: a copy-on-write fork of the parent branch's data (or a point in its history via parent_lsn or parent_timestamp). Without an endpoints array the branch has NO compute and cannot accept connections - add one here or with Neon: Create Compute Endpoint. Branch creation is asynchronous; poll the returned operations. Reversible with Neon: Delete Branch.

Neon: Create Compute Endpoint

Create a compute endpoint on a branch: read_write (one per branch - fails if the branch already has one) or read_only (a read replica; multiple allowed). A branch created without compute needs this before anything can connect. Running compute accrues the project's compute usage. Reversible with Neon: Delete Compute Endpoint.

Neon: Create Database

Create a database on a branch, owned by an existing role. Asynchronous - poll the returned operations. Reversible with Neon: Delete Database.

Neon: Create Project

Create a Neon project: a new Postgres instance with a default branch, database, role, and read-write compute. Every field is optional - an empty config creates a project with generated names in the default region. The response includes connection URIs with LIVE credentials. Counts against the account or organization's project limit. Reversible with Neon: Delete Project.

Neon: Create Role

Create a Postgres role on a branch. The response includes the generated PASSWORD (a live credential stored in automation execution records) - it is also recoverable later via a password reset. Reversible with Neon: Delete Role.

Neon: Delete Branch

DESTRUCTIVE: delete a branch with its databases, roles, and compute endpoints; connections to it stop working. By default the delete is soft - the API spec documents a 7-day recovery window - but hard_delete=true removes it immediately and permanently. The default branch, a protected branch, and a branch with children cannot be deleted.

Neon: Delete Compute Endpoint

DESTRUCTIVE: delete a compute endpoint. Neon documents that a compute deleted and added back later gets different connection details, so every connection string naming this one breaks permanently. Branch data is untouched.

Neon: Delete Database

DESTRUCTIVE: drop a database from a branch. Every table and row in it on THIS branch is gone (other branches keep their own copies). Recoverable only through the project's point-in-time restore window, if any.

Neon: Delete Project

DESTRUCTIVE: delete a project and EVERYTHING in it - all branches, databases, roles, and compute endpoints. Every connection string to the project stops working immediately. Neon keeps recently deleted projects recoverable for a limited window via the Console, but treat this as permanent: export anything you need first.

Neon: Delete Role

DESTRUCTIVE: delete a role from a branch. Anything authenticating as it stops working immediately, and the role's grants are gone. A role that owns a database cannot be deleted - reassign ownership first with Neon: Update Database.

Neon: Reset Role Password

Generate a new password for a role. The OLD password stops working immediately and cannot be recovered, so every client using it must be updated with the new one - which is returned in the response (a live credential stored in automation execution records). The credential-rotation node.

Neon: Restart Compute Endpoint

Restart a compute endpoint (suspend then start). Open connections drop and there is a brief outage while it comes back - the standard fix for a wedged compute or to apply pending configuration.

Neon: Set Default Branch

Make a branch the project's default (primary) branch - the one connection URIs and branch creation fall back to when no branch is named. The previous default stays intact, so this is reversible by setting it back.

Neon: Start Compute Endpoint

Start a suspended compute endpoint so it can accept connections (the warm-up move before a batch job, instead of eating a cold start). Running compute accrues the project's compute usage. Asynchronous - poll the returned operation. Reversible with Neon: Suspend Compute Endpoint.

Neon: Suspend Compute Endpoint

Suspend a compute endpoint immediately (scale to zero now rather than waiting for the idle timeout). Open connections drop; the next connection wakes it with a cold start. Reversible with Neon: Start Compute Endpoint.

Neon: Update Branch

Update a branch: rename it, toggle the protected flag, or set an expiry time for automatic deletion. Only fields you fill are sent.

Neon: Update Compute Endpoint

Update a compute endpoint: change autoscaling limits, the scale-to-zero timeout, the display name, or disable connections (disabled=true schedules a suspend). Only fields you fill are sent; the change may restart the compute via the returned operations.

Neon: Update Database

Rename a database or transfer it to a different owning role. Renaming breaks connection strings that name the old database. Only fields you fill are sent.

Neon: Update Project

Update project properties: rename it, change the point-in-time restore window, or change the default compute autoscaling and scale-to-zero settings. Only fields you fill are sent. Reversible by writing the previous values back (read them first with Neon: Get Project).

Connecting Neon takes one credential

Neon authenticates API requests with an API key sent as a Bearer header. Any Neon user can create a personal key in the Neon Console under Account settings, then API keys. Organization admins can also create organization keys and project-scoped organization keys under the organization's Settings, then API keys; a project-scoped key works only inside its project, which makes it the natural credential for a single-project automation. All three variants are sent the same way and all three work with this connector. Neon shows the key once, at creation.

1

Sign in at console.neon.tech, open your account menu, and go to Account settings, then API keys. For a key owned by an organization, switch to the organization and open Settings, then API keys instead, where admins create organization keys or project-scoped keys.

2

Create a new key and copy it when it is shown. Neon displays the secret once at creation and never again.

3

In Mattering Automations, open Connectors, click Add Connector, choose Neon, and create a credential with the API key.

4

Click Test Connection. Mattering calls Neon's current-user endpoint, which works with every key variant and no parameters: a successful result proves the credential, an error means the key is wrong or revoked.

5

All 39 Neon nodes appear in the canvas palette. Run Neon: List Projects first: the project ID it returns feeds every other Neon node.

Common uses for the Neon MCP

A database branch for every pull request

The workflow Neon's branching model was built for. A pull request webhook fires, Neon: Create Branch forks the parent branch's data copy-on-write with an endpoints array so the branch gets its own compute, Neon: Get Operation polls until the work is finished, and Neon: Get Connection URI hands back a ready-to-use Postgres connection string for CI. When the pull request closes, Neon: Delete Branch tears the branch down; the delete is soft by default, with a 7-day recovery grace period documented in Neon's API.

Compute that runs when the work does

Neon computes scale to zero when idle, and the endpoint lifecycle nodes let workflows steer that directly. Neon: Start Compute Endpoint warms a suspended compute before a scheduled batch job so the job does not eat the cold start, Neon: Suspend Compute Endpoint scales it back to zero the moment the job reports done instead of waiting out the idle timeout, and Neon: Restart Compute Endpoint is the standard fix for a wedged compute, with a brief outage while it comes back. Neon: Update Compute Endpoint changes the autoscaling limits and the scale-to-zero timeout themselves.

Consumption reporting that lands in a database

Neon: Get Project Consumption pulls per-project usage history at hourly, daily, or monthly granularity, and Neon: Get Branch Consumption breaks it down to the branch, the finest-grained cost attribution Neon offers. A scheduled sweep can write the numbers into a Mattering database and open a task when a branch's compute jumps. Per Neon's API spec these endpoints are plan-gated: the per-project node serves accounts on Launch, Scale, Agent, Business, and Enterprise plans, and the per-branch node serves accounts on paid usage-based Launch, Scale, Agent, and Enterprise plans.

Credential rotation on a schedule

Neon: Reset Role Password generates a new password for a Postgres role and returns it in the response; per Neon's API the old password stays valid only until the reset's operations finish, existing connections to the compute are dropped, and the old value cannot be recovered, so the same workflow should carry the new value to whatever uses it, then confirm with a verification step. Because the response is a live credential and lands in automation execution records, the honest pattern is a tightly scoped workflow that rotates and delivers in one run. The endpoint that reveals a role's stored password is deliberately not shipped; rotation is the supported move.

An AI agent that manages branches with guardrails

Neon: List Branches shows an agent what exists, with each branch's parent and default flag, Neon: Get Branch reads one branch's state and usage counters, and Neon: Create Branch and Neon: Update Branch do the reversible work, including toggling a branch's protected flag and setting an expiry time for automatic cleanup. Neon: Delete Branch is flagged destructive so workflows gate it behind a condition or an approval task, and Neon's own rules back the guardrail up: the default branch, a protected branch, and a branch with children cannot be deleted at all.

Watching the work Neon does asynchronously

Most Neon writes do not finish in the request: they schedule operations, and the response tells you which. Neon: Get Operation polls one operation until its status is finished, failed, or error, which is the step to put between a create and anything that depends on it. Neon: List Operations is the audit view: a project's recent operations newest first, with status and duration, so a monitoring workflow can spot failed operations and open a task with the details instead of letting them disappear into the console.

Example: A pull request opens: branch the database, wait for it, hand back a connection string

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

1

Trigger: an inbound webhook from your repository fires when a pull request opens, carrying the branch name and pull request number.

2

Neon: Create Branch forks the project's default branch copy-on-write, with an endpoints array so the new branch gets its own read-write compute and can accept connections.

3

Neon: Get Operation polls the operation the create returned until its status is finished.

4

Neon: Get Connection URI builds a ready-to-use Postgres connection string for the new branch. The URI embeds the role's password, so the workflow treats it as the live credential it is and passes it only where it is needed.

5

The workflow delivers the connection string to CI and opens a task in Mattering Productivity naming the pull request and the branch, so teardown has an owner.

6

When the pull request closes, a second workflow runs Neon: Delete Branch. The delete is soft by default, with a 7-day recovery grace period documented in Neon's API, though Neon marks branch recovery as a preview feature, so a mistaken teardown is usually not the end of the story.

Neon MCP questions, answered

What Neon operations are supported?

39 nodes on the Neon API v2: 20 query nodes and 19 action nodes covering projects (list, get, create, update, delete, plus connection URIs), branches (list, get, create, update, delete, set default), compute endpoints (list, get, create, update, delete, start, suspend, restart), per-branch databases and roles including password reset, the operations feed for polling Neon's asynchronous work, regions, organizations, a read-only API key audit list, and the consumption metrics family. Deliberately not shipped: API key creation and revocation, the reveal-password endpoint, Neon Auth, snapshots and restore operations, and Neon's Data API surfaces.

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.

Neon has an official MCP server. Why use this connector?

Neon hosts an official MCP server at mcp.neon.tech, and if all you want is an assistant talking to Neon alone, it is a genuine option. This connector earns its place when Neon is one step in a larger workflow: the same canvas holds your other connectors and the Mattering platform itself, so a pull request can branch the database and then open a review task, a branch delete can wait behind a human approval step, and a consumption sweep can write into a database next to the rest of your work. Credentials live in one place with your other connector secrets, and the same nodes serve visual automations and AI agents alike.

Do I need a paid Neon plan?

Neon has a Free plan, and any user can create a personal API key from Account settings, so the core surface, projects, branches, compute endpoints, databases, roles, and operations, works without paying. The consumption metrics nodes are the plan-gated exception, per Neon's own API spec: the legacy per-project node serves Scale, Business, and Enterprise plan projects, the current per-project node serves accounts on Launch, Scale, Agent, Business, and Enterprise plans, and the per-branch node serves accounts on paid usage-based Launch, Scale, Agent, and Enterprise plans.

Why do write nodes return operations instead of a finished result?

Because that is how Neon works: most writes are asynchronous. Creating a branch or starting a compute schedules operations, and the response includes them with their IDs. Neon: Get Operation polls one until its status reaches finished, failed, or error, and that polling step belongs between any Neon write and the step that depends on its result. Neon: List Operations shows a project's recent operations newest first, which makes it the audit and monitoring view of everything the action nodes kicked off.

Is deleting a branch recoverable?

By default, yes, for a while, with one caveat: Neon's API documents that deleted branches can be recovered within a 7-day grace period, unless the delete was run with hard_delete set to true, which removes the branch immediately and permanently. The caveat is that Neon marks branch recovery as a preview feature not available to all users, and its console docs still describe branch deletion as permanent, so treat the grace period as a safety net rather than a guarantee. Recovery itself happens through Neon, since this connector deliberately does not ship the restore endpoints. Neon also refuses some deletes outright: the default branch, a protected branch, and a branch with children cannot be deleted. Compute endpoints are the sharper edge: Neon documents that a compute deleted and added back later gets different connection details, so connection strings naming the old endpoint break permanently even though the branch data survives.

Can a workflow run SQL against my Neon databases?

Not through this connector. These nodes drive Neon's management API: they create and manage the projects, branches, computes, databases, and roles, and Neon: Get Connection URI hands a workflow a standard Postgres connection string for whatever needs to connect. Executing SQL is a job for the thing holding that connection string, not for the management surface, and keeping the two apart is deliberate.

How does the connector handle Neon's live credentials?

Honestly and narrowly. Four responses carry live credentials and their nodes say so: Neon: Get Connection URI returns a URI with the role's password embedded, Neon: Create Project returns connection URIs for the new project, and Neon: Create Role and Neon: Reset Role Password return the role's password. Those values land in automation execution records, so treat downstream use accordingly. In the other direction, the connector refuses to mint or expose credentials it does not need: API key creation and revocation stay in the Neon Console, the key list node never includes token material because Neon only shows a token once at creation, and the reveal-password endpoint is omitted in favor of reset.

39 nodes waiting on the canvas

Put Neon 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. Neon is a product of its respective owner; Mattering is an independent platform.

Start Free Explore our Products