Menu

Mattering Automations Deepgram integration

Connect Deepgram to Mattering Automations: pre-recorded transcription from a URL, text intelligence, the model catalog, and the project, key, member, usage, and billing management plane, authenticated with a Deepgram API key sent as Authorization with the Token scheme.

The Mattering Automations Deepgram integration adds Deepgram to your automation canvas: transcribe pre-recorded audio and video with speaker labels, smart formatting, redaction, and keyword boosting; run text intelligence over any text for summaries, topics, intents, and sentiment; read the live model catalog; and manage projects, API keys, members and their scopes, invites, request history, usage, billing, and credit balances.

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

Three facts shape how this integration behaves, and knowing them up front saves an afternoon. The Authorization header scheme word is Token, not Bearer, so a Bearer header returns 401 with a valid key. Audio reaches Deepgram as a URL that Deepgram fetches itself, never as an upload, which is a deliberate decision explained below. And exactly two of the 26 nodes are metered pay-per-use, billed by audio duration or by tokens, while the other 24 are free management calls.

Before you start

  • A Deepgram account. Keys are created in the console at console.deepgram.com; Deepgram's pricing page advertises a free starting credit for new accounts.
  • Access to a Deepgram project's API Keys tab, with a scope high enough for the nodes you intend to run. Transcription and text intelligence need less scope than the management write nodes do.
  • A Mattering workspace with access to the Automations app.
  • For transcription: audio or video reachable at a URL that Deepgram can fetch. A public HTTPS link works, and so does a time-limited signed link from object storage. There is no file upload path.

Create a Deepgram API key

Mattering authenticates to Deepgram with an API key sent in an Authorization header on every request. The credential is a single opaque secret value: the connect form asks for the key and nothing else, and the integration formats the header itself.

Open the Deepgram console at console.deepgram.com and select the project you want to automate.
Open API Keys and create a key, choosing the lowest scope that covers the nodes you plan to run. The management write nodes need an admin or owner scope; transcription and text intelligence do not.
Copy the secret.
Deepgram shows the secret once, at creation. Navigate away without copying it and the key cannot be recovered, only replaced. Note also that this integration has no create-key node, on purpose: Deepgram's create-key response returns the full secret, and running it from an automation would write a live key into an execution record that anyone with run-history access can read. Create keys in the console instead.
The scheme word is Token, not Bearer. Deepgram's reference documents Authorization with the Token scheme verbatim and requires that header on every one of its operations, and a Bearer header returns 401 even when the key is perfectly valid. Inside this integration you never type it, because the connector builds the header for you. It only becomes your problem if you also call Deepgram from a generic HTTP node.

Connect Deepgram to Mattering

In Mattering Automations, open Connectors and click Add Connector.
Choose Deepgram from the list.
Click Create new credential, paste the API key into the single value field, and save. There is no header name to type and no scheme to pick; the integration applies the Authorization header with the Token scheme for you.
The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.
Click Test Connection. Mattering calls Deepgram's projects endpoint with the Token header. The call costs nothing, and its response carries only project ids and names, with no key material in it at all.
Click Connect. All 26 Deepgram nodes appear in your canvas palette.

Verify it works

After connecting, open any automation canvas and check the palette: a Deepgram section should list the query and action nodes. Drop Deepgram: List Projects onto the canvas and run a test step. It takes no configuration and costs nothing, which is exactly why it is also the connection test. A successful response lists the projects the key can see, each with a project_id and a name and nothing else. Note the project_id, because most of the management nodes need one.

To confirm more of the surface without spending anything, run Deepgram: List Models for the live catalog of speech to text models and text to speech voices, and Deepgram: Get Usage Breakdown with that project_id and a date range. Everything in this verify path is a free management read. Save the first metered call for when you are ready: Deepgram: Transcribe Audio from URL against a short public sample clip is the honest smoke test, and keeping the clip short keeps the bill to a few seconds of audio.

Node reference

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

Read and query nodes 16

Deepgram: Get Billing Breakdown

deepgram_get_billing_breakdown

Dollar spend for a project over a date range, optionally grouped by API key, deployment, line item, or tag. Where the usage breakdown node reports hours and tokens, this one reports money. Free read.

Deepgram: Get Member Scopes

deepgram_get_member_scopes

Read the permission scopes a member holds on a project. Run it before changing scopes so you know the exact strings this project uses. Free read.

Deepgram: Get Model

deepgram_get_model

Fetch metadata for one model by its uuid: canonical name, architecture, supported languages, version, and whether it supports batch or streaming. Free read.

Deepgram: Get Project

deepgram_get_project

Fetch one Deepgram project by id: its name and whether it has opted out of the Model Improvement Program. Free read.

Deepgram: Get Project Balances

deepgram_get_balances

Read the outstanding credit balances on a Deepgram project, each with an amount and its units (such as USD). Since every transcription draws this down, this is the node for a low-balance alert automation. Free read.

Deepgram: Get Project Key

deepgram_get_key

Fetch one API key record by id: its comment, scopes, tags, expiration date, and owning member. The secret key value is never returned, only shown once at creation time in the Deepgram console. Free read.

Deepgram: Get Request

deepgram_get_request

Fetch one request record by id: which path was called, which API key made it, when, what status code came back, and whether a callback was used. This is the request LOG, not a transcript store, so do not rely on it to retrieve the output of a callback-based transcription. Free read.

Deepgram: Get Usage Breakdown

deepgram_get_usage_breakdown

Usage totals for a project over a date range: audio hours, agent hours, tokens in and out, text-to-speech characters, and request counts, optionally grouped by API key, endpoint, model, method, tag, or deployment. This is the node to wire into a scheduled cost-watch automation. Free read.

Deepgram: List Models

deepgram_list_models

List every Deepgram model available to the account, split into speech-to-text models (data.stt) and text-to-speech voices (data.tts) with their languages, versions, and uuids. Use it to populate the 'model' field on the transcription node with a value that is live today rather than one hard-coded months ago. Free read.

Deepgram: List Project Invites

deepgram_list_invites

List the outstanding invitations on a Deepgram project, each with the invitee's email and the scope they were invited with. Free read.

Deepgram: List Project Keys

deepgram_list_keys

List the API keys on a project for auditing: each entry carries the key id, its comment, its scopes, its creation date, and the member it belongs to. Deepgram does NOT return the secret key value here, so this is safe to run in an automation. Free read.

Deepgram: List Project Members

deepgram_list_members

List the members of a Deepgram project with their member ids, email addresses, names, and scopes. Free read.

Deepgram: List Projects

deepgram_list_projects

List every Deepgram project the API key can see. Takes no configuration and costs nothing, so it doubles as the credential health check. The response carries only project ids and names, never key material. Most other management nodes need a project_id from here.

Deepgram: List Purchases

deepgram_list_purchases

List the credit purchases on a project: the original amount of each order, its units, when it was created, and when it expires. Pair it with the balances node to see how much of each purchase is left. Free read.

Deepgram: List Requests

deepgram_list_requests

List the API requests a Deepgram project has served, with filters for date range, endpoint, method, status, and API key. The audit trail behind a billing question or a failing integration. Free read.

Deepgram: List Usage Fields

deepgram_list_usage_fields

List which models, features, tags, and processing methods the project actually used in a date range. Run it before the usage breakdown node to learn the valid filter values instead of guessing them. Free read.

Action nodes 10

Deepgram: Analyze Text

deepgram_analyze_text

COSTS MONEY ON EVERY RUN. Deepgram text intelligence is metered pay-per-use, billed by the tokens in the text you submit and the output produced, so a long document costs proportionally more than a short one. No rate is quoted here on purpose because rates change: see https://deepgram.com/pricing for the current metering. Run Deepgram text intelligence over plain text: summarization, topic detection, intent recognition, and sentiment scoring, in any combination. Feed it a transcript from the Deepgram: Transcribe Audio from URL node, an email body, a support ticket, or any other text. Supply either 'text' (the text itself) or 'url' (a URL Deepgram fetches the text from), never both.

Deepgram: Create Project Invite

deepgram_create_invite

Invite someone to a Deepgram project by email at a given scope. Sends them a real invitation email. Reversible with the Deepgram: Delete Project Invite node while it is still pending. Free.

Deepgram: Delete Project

deepgram_delete_project

PERMANENTLY DELETE a Deepgram project. This is not reversible: the project, its API keys, and its member assignments go with it, and any automation still using a key from that project stops working. Use only with a project id you are certain about.

Deepgram: Delete Project Invite

deepgram_delete_invite

Revoke a pending invitation by email address. Classed as a reversible write rather than destructive because nothing is lost: send the invite again to restore it. It has no effect on someone who has already joined, which is the Deepgram: Remove Project Member node.

Deepgram: Delete Project Key

deepgram_delete_key

PERMANENTLY REVOKE a Deepgram API key. Not reversible: the secret cannot be recovered, a replacement key is a different secret, and anything still authenticating with the deleted key starts failing immediately. Useful as the last step of a credential-rotation flow.

Deepgram: Leave Project

deepgram_leave_project

Remove the account behind this API key from the project. Destructive in practice: once the key's owner has left, the same credential may lose access to the project entirely and cannot re-add itself; another project member has to send a fresh invite.

Deepgram: Remove Project Member

deepgram_remove_member

REMOVE a person from a Deepgram project. Destructive: the member loses access at once, and getting them back means a fresh invite they have to accept. Their API keys on the project stop working.

Deepgram: Transcribe Audio from URL

deepgram_transcribe_url

COSTS MONEY ON EVERY RUN. Deepgram is metered pay-per-use and speech-to-text is billed by audio duration, so a one-hour recording costs roughly sixty times what a one-minute clip costs. No rate is quoted here on purpose because rates change: see https://deepgram.com/pricing for the current metering. New accounts get a free starting credit. Transcribe a pre-recorded audio or video file with Deepgram speech-to-text. Audio reaches Deepgram as a URL, never as an upload: the canvas cannot produce a binary request body, so this node sends the documented JSON body {"url": "..."} and Deepgram fetches the media itself. The plain transcript is at data.results.channels[0].alternatives[0].transcript, with per-word timings and confidences beside it, plus optional speaker labels, paragraphs, utterances, summaries, topics, intents, and sentiment depending on which options you turn on. Live streaming transcription is a WebSocket protocol and is not available as an automation node.

Deepgram: Update Member Scopes

deepgram_update_member_scopes

Set a member's permission scope on a project. Reversible: read the previous value with the Deepgram: Get Member Scopes node first and write it back to undo. Free.

Deepgram: Update Project

deepgram_update_project

Rename a Deepgram project. Reversible: set the old name back to undo it. Free.

Using the integration

On the automation canvas

Deepgram nodes chain with every other node. A recording URL arriving on a webhook can run through Deepgram: Transcribe Audio from URL and land as a task in Mattering Productivity with the transcript in the description; Deepgram: Analyze Text can turn that transcript into a summary and a sentiment score written to a Mattering database; and a scheduled Deepgram: Get Project Balances can message a channel before the credit runs out. The 16 read nodes are free, so they can run on a schedule without watching the meter.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and Matter can transcribe a recording, summarize what was said, report how many audio hours a project burned last week, or list who still holds an API key on a project, through the same nodes your workflows use. The management reads are free and side-effect-free, which makes them the safest Deepgram surface to hand an agent; the two metered nodes spend real money on every run, so gate them the way you would any spending step.

Audio reaches Deepgram as a URL, not an upload

This is the single thing most likely to make someone think the integration is broken, so it is worth stating plainly: there is no file upload box on Deepgram: Transcribe Audio from URL, and there is not meant to be one. Deepgram's documented request body for pre-recorded transcription is JSON with a single required url, and Deepgram fetches the media itself. A raw binary upload exists in Deepgram's prose guides, but an automation canvas cannot produce a binary request body: node configuration is JSON, and inlining a file as base64 would put megabytes into a configuration record for a ten minute clip. So the node sends the documented JSON body and the audio has to be reachable at a URL Deepgram can fetch. A public HTTPS link works; so does a signed or temporary URL from object storage, as long as it has not expired by the time the node runs. Most pipelines already move recordings that way.

What costs money, and what the output costs you in size

Deepgram is metered pay-per-use. Deepgram: Transcribe Audio from URL is billed by audio duration, so an hour of audio costs proportionally more than a minute, and Deepgram: Analyze Text is billed by the tokens in and out, so a long document costs more than a short one. No rate appears in this integration anywhere, on purpose, because rates change and per-model rates differ; deepgram.com/pricing is the source. Turning on summaries, topics, intents, or sentiment during transcription adds token-metered cost on top of the audio charge, and each of those fields says so in its help text. Size is a separate axis: transcription responses are deliberately not truncated, because the response is nested JSON and capping it would destroy the very paths the node exists to provide, including the word-level timings, the speaker labels, and the alternatives. Instead the size-inflating options are flagged in the field help. Turning on word-level utterances, paragraphs, and multichannel together produces a much larger execution record than the plain transcript does.

Callbacks are exposed, but not automated

Both metered nodes carry callback and callback_method fields, and setting them changes what the node returns. With a callback set, Deepgram answers immediately with only a request_id and posts the finished result to your URL later, so the transcript will not be in the node's output and the flow has to continue from a webhook trigger listening on that URL: transcribe node, then webhook trigger, then the rest of the flow. There is no polling alternative, and this integration does not pretend otherwise: Deepgram: Get Request reads the request log record, which is what was called and what status came back, not the body of the result. No node hides a sleep or a poll loop, because a retry cycle should be graph structure you can see and edit rather than a black box burning executor time. Leaving callback blank gives the ordinary synchronous call that returns the transcript inline; that is the default and the recommended path, and the node carries a long timeout so a long file can finish that way.

The management plane, and the four destructive nodes

Most of this integration is free management calls: Deepgram: List Project Keys for a key audit that never returns a secret, Deepgram: List Project Members and Deepgram: Get Member Scopes for access, Deepgram: List Requests for the audit trail behind a billing question, and the usage, billing, balance, and purchase reads for spend. Four nodes are flagged destructive because they irreversibly remove something rather than merely using a DELETE verb: Deepgram: Delete Project takes the project, its keys, and its member assignments with it and nothing brings them back; Deepgram: Delete Project Key revokes a secret that cannot be recovered, which includes this connector's own credential if you point it at the wrong key; Deepgram: Remove Project Member cuts a person's access at once and their keys on the project stop working; and Deepgram: Leave Project removes the account behind this key, after which the same credential may not be able to re-add itself. By contrast Deepgram: Delete Project Invite is deliberately not flagged destructive, because re-sending the invite fully restores the prior state.

Troubleshooting

Test Connection fails with a 401, or every node returns 401 at once
Check the scheme word first. Deepgram's Authorization header takes Token, not Bearer, and a Bearer header is refused even when the key is valid; that is the most common cause by a wide margin for anyone arriving from another AI API. Within this integration the header is built for you, so if the Token scheme is already in play the remaining causes are a key that was revoked in the console, whitespace pasted along with the secret, or a key belonging to a deleted project. Create a fresh key in the Deepgram console and update the credential on the connector.
A management node returns a 404 or an error about the project id
Almost every management node is project-scoped and needs a project_id that the flow has not supplied, or has supplied from the wrong account. Run Deepgram: List Projects first: it takes no configuration, costs nothing, and returns the ids the key can actually see. Reuse that value across the workflow. If the list comes back empty, the key authenticates but belongs to an account with no projects on it yet.
Transcription fails because Deepgram could not fetch the audio
Deepgram fetches the media server-side, so the URL has to be reachable from Deepgram at the moment the node runs: no login wall, no expired signed link, and a direct media response rather than a player page. Signed URLs are fine, but check the expiry window against how long the flow takes to reach the node. There is no upload alternative and no base64 fallback, because the canvas cannot produce a binary request body; if the file only exists locally, put it somewhere fetchable first.
The transcription node returned a request_id and no transcript
A callback is set on the node. Deepgram then answers immediately with the request_id and posts the finished result to your callback URL later, so the transcript never appears in the node's output. Either clear the callback field to get the ordinary synchronous call, or continue the flow from a webhook trigger listening on that URL. Do not try to poll for the result: Deepgram: Get Request returns the request log record, which is what was called and what status came back, not the transcript itself.
One transcription filled the execution record
That is the size-inflating options rather than a fault. Utterances add a second full copy of the text with its own word arrays, paragraphs add another copy of the transcript, and multichannel doubles the response for stereo audio; turning all three on at once is what produces an enormous record. Transcription responses are deliberately never truncated, because the response is nested JSON and capping it would leave a string that no longer parses, destroying the word timings, speaker labels, and alternatives that the node exists to provide. Turn off the options you are not consuming, and pick the flat text out of data.results.channels[0].alternatives[0].transcript in the next node if that is all you need downstream.
Speaker labels are missing, or the diarize option seems to be ignored
The diarize parameter is deprecated in favour of diarize_model, which both enables speaker diarization and selects its version. Both are available on the node, with the older one marked deprecated in its help text, because every older Deepgram tutorial and snippet uses diarize and removing it would break copied configurations. For new work, set diarize_model and leave diarize alone.
summarize is rejected, or Deepgram: Analyze Text fails before it is sent
Two different traps that look alike. The summarize option behaves differently on the two surfaces: on transcription it accepts either the string v2 or a boolean, while on text intelligence it is boolean-only, so a value copied from one node to the other can be refused. Separately, Deepgram: Analyze Text requires exactly one of text or url, and a run with neither filled in fails locally with a clear message rather than sending an empty body. Remember that it is a separate endpoint from transcription: it accepts text or a URL to fetch text from, never an audio file.
Everything stopped working right after an API key cleanup
Deepgram: Delete Project Key permanently revokes a secret, and if the key it was pointed at is the one behind this connector's credential, every Deepgram node starts failing immediately and the secret cannot be recovered. A replacement is a different secret, so create a new key in the console and update the credential. If the flow ran Deepgram: Leave Project instead, the account behind the key is out of the project and may not be able to re-add itself; another project member has to send a fresh invite. Both nodes are flagged destructive for exactly this reason, so gate them behind a condition or a manual run.

Deepgram 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