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.
Connect Deepgram to Mattering
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
A management node returns a 404 or an error about the project id
Transcription fails because Deepgram could not fetch the audio
The transcription node returned a request_id and no transcript
One transcription filled the execution record
Speaker labels are missing, or the diarize option seems to be ignored
summarize is rejected, or Deepgram: Analyze Text fails before it is sent
Everything stopped working right after an API key cleanup
Related
The Deepgram MCP
What connecting Deepgram unlocks for AI agents and automations, with common uses and FAQs.
More guides
All Automations documentation
Every integration guide, plus how connectors, credentials, and workflows fit together.
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.