Mattering Automations Groq integration

Connect Groq to Mattering Automations: chat completions, the Responses API, Whisper transcription and translation, batch jobs, files, and LoRA fine-tunes as workflow steps, authenticated with a Groq API key.

Get the credential Connect Verify Node reference Troubleshooting

The Mattering Automations Groq integration puts Groq's LPU inference on your automation canvas: run a chat completion or a Responses API call inside a workflow step, transcribe or translate audio from a URL with Whisper, submit and poll batch jobs, manage the files those batches read and write, and register LoRA fine-tunes on enterprise accounts.

Setup is one API key from the Groq console. This guide covers creating the key, connecting it, a verify path that costs nothing to run, and the full node reference, and it ends with the failure modes worth recognizing on sight.

Before you start

A Groq account with API access at console.groq.com. Groq has a free tier, so a key works for testing without a paid plan.
A Mattering workspace with access to the Automations app.
For the audio nodes, somewhere to host audio at a publicly reachable URL. Groq fetches the audio itself; there is no local file upload.
For the four fine-tuning nodes, an enterprise-tier Groq account. Other accounts get an authorization error on those nodes.

Create a Groq API key

Mattering authenticates to Groq with an API key sent as an Authorization bearer header. It is a single field: no organization id, no version header, no OAuth flow to complete.

Click Create API Key, name it after where it will be used, such as Mattering Automations, and create it.

The key is shown once, at creation. Copy it before you close the dialog; if you lose it you have to create a new one.

Copy the key and keep it somewhere safe until you have pasted it into Mattering.

Connect Groq to Mattering

In Mattering Automations, open Connectors and click Add Connector.

Choose Groq from the list.

Click Create new credential, paste the API key, and save.

The credential is stored encrypted in Google Secret Manager and never appears in workflow logs.

Click Connect. All 18 Groq nodes appear in your canvas palette.

The Groq connector does not ship a built-in auth test, so Test Connection has nothing to call for this one. Verify with the read-only node in the next section instead.

Verify it works

Open any automation canvas and check the palette: a Groq section should list nine query nodes and nine action nodes. Drop Groq: List Models onto the canvas and run a test step. It takes no parameters and is read-only, so a successful response returns every model your key can call, each with its context window and owner. It costs no tokens, which makes it the cheapest credential check available.

To confirm inference itself works, add Groq: Create Chat Completion, set the model to a small current model id from that list, put one short message in the messages array, and keep max_completion_tokens low. A successful run returns the reply at choices[0].message.content along with token usage.

Node reference

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

Read and query nodes 9

Groq: Download File Content

groq_get_file_content

Download a file's contents as text. Batch output and error files are JSONL, so the node also returns each line parsed into a `lines` array you can loop over.

Groq: Get Batch

groq_get_batch

Get one batch job: status, request counts, and the output / error file IDs to download once it completes.

Groq: Get File

groq_get_file

Get one file's metadata: size in bytes, filename, purpose, and creation time.

Groq: Get Fine-Tuning

groq_get_fine_tuning

Get one registered fine-tune, including the fine_tuned_model ID you pass as `model` on a chat completion. Enterprise tier only.

Groq: Get Model

groq_get_model

Get one model's details: owner, whether it is active, its context window, and its max completion tokens.

Groq: List Batches

groq_list_batches

List the batch jobs on the account with their current status and request counts.

Groq: List Files

groq_list_files

List the files uploaded to the account, with size, filename, and purpose.

Groq: List Fine-Tunings

groq_list_fine_tunings

List the LoRA fine-tunes registered on the account. Enterprise tier only: other accounts get an authorization error.

Groq: List Models

groq_list_models

List every model the API key can call, with each model's context window and owner. Takes no parameters, so it doubles as the credential health check.

Action nodes 9

Groq: Cancel Batch

groq_cancel_batch

Cancel a batch job that is still validating or in progress. Already-completed requests keep their results.

Groq: Create Batch

groq_create_batch

Kick off an asynchronous batch job over a previously uploaded JSONL file. Batch runs are discounted and return results as an output file once the window closes.

Groq: Create Chat Completion

groq_create_chat_completion

Run a chat completion on Groq's LPU inference. Send a messages array, get the assistant reply back at choices[0].message.content plus token usage. Supports tool calling, JSON-mode / structured output, and reasoning models. Non-streaming.

Groq: Create Response

groq_create_response

Run a prompt through Groq's Responses API and read the reply straight off output_text. Simpler than chat completions for single-shot generation, and it is the surface that supports built-in tools (code interpreter, browser search, remote MCP). Non-streaming.

Groq: Delete File

groq_delete_file

Permanently delete an uploaded file from the Groq account.

Groq: Delete Fine-Tuning

groq_delete_fine_tuning

Delete a registered LoRA fine-tune. The adapter stops being callable as a model. Enterprise tier only.

Groq: Register Fine-Tuning (LoRA)

groq_create_fine_tuning

Register an already-uploaded LoRA adapter archive as a callable fine-tuned model. Groq does not train adapters; you build them elsewhere and upload the .zip with purpose 'fine_tuning' first. Enterprise tier only.

Groq: Transcribe Audio (URL)

groq_create_transcription

Transcribe an audio file into text with Whisper on Groq. Takes a publicly reachable audio URL (Groq fetches it), this node does not upload local files. Formats: flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, webm.

Groq: Translate Audio to English (URL)

groq_create_translation

Translate non-English audio into English text with Whisper on Groq. Takes a publicly reachable audio URL, so this node does not upload local files.

Using the integration

On the automation canvas

Groq nodes chain with everything else: pull a record, generate or classify with Groq: Create Chat Completion, then write the result into a task, a message, or a database row. Template references resolve inside nested JSON, so you can drop an upstream node's output straight into one entry of the messages array rather than templating the whole array as a single blob.

Chat completions or the Responses API

Groq: Create Chat Completion is the familiar messages in, choices out shape, with tool calling, JSON mode and structured output, and reasoning parameters. Groq: Create Response is simpler for single-shot generation: the reply comes back on output_text, and it is the surface that carries Groq's built-in tools. Both are non-streaming, so each node returns one complete response.

Audio in, text out

Groq: Transcribe Audio (URL) and Groq: Translate Audio to English (URL) take a publicly reachable audio URL that Groq fetches for itself. Accepted formats are flac, mp3, mp4, mpeg, mpga, m4a, ogg, wav, and webm, and the size limits that apply to your tier are spelled out in the URL field's help text.

Batch jobs and the files around them

Upload the JSONL input out of band, then Groq: Create Batch starts the run over that file id, Groq: Get Batch reports status and the output and error file ids, and Groq: Download File Content returns the JSONL as text plus each line already parsed into a lines array a For Each node can loop. Groq: Cancel Batch stops a run that is still validating or in progress.

From AI assistants over MCP

Every node speaks MCP, the open protocol for connecting AI assistants to tools. Claude, ChatGPT, and Matter can drive them, so an assistant can build and run a workflow that hands the bulk generation to Groq.

Troubleshooting

Every node returns a 401

The key is wrong, revoked, or truncated on paste. Groq shows a key once at creation, so a half-copied key is a common cause. Create a fresh key in the Groq console, update the credential on the connector, and run Groq: List Models to confirm the fix.

A fine-tuning node returns an authorization error

The four LoRA nodes call Groq's fine-tunings surface, which Groq restricts to enterprise-tier customers by request. A free or standard key gets an authorization error on List, Get, Register, and Delete Fine-Tuning no matter how the node is configured. The account itself needs enterprise access, and LoRA is also unavailable on regional endpoints.

An audio node fails because Groq cannot fetch the recording

Transcription and translation hand Groq a URL and Groq downloads the audio itself, so a link that only resolves inside your network, a signed URL that has already expired, or a page behind a login all fail on Groq's side rather than in the workflow. Open the URL in a private browser window with no session: if the audio downloads there, Groq can reach it too. Check the format is one of the accepted list as well.

A node returns a model not found error

The model id is not available to your key, or Groq has retired it. Model availability changes on a rolling basis, so an id copied from an old workflow or from another provider can stop resolving. Run Groq: List Models to see what the key can call right now and set the model field to one of those ids. The field is free text on purpose, so it does not rot the way a fixed dropdown would.

A chat completion returns a 400 on a parameter

Groq's OpenAI compatibility is close but not total: it rejects logprobs, logit_bias, top_logprobs, a name on a message, and n above 1. Those fields are absent from the node config for that reason, but they can still reach Groq through the free-form extra_body object, which merges last and overrides the typed fields. Strip them from extra_body if a payload copied over from OpenAI starts failing.

Create Batch returns a job instead of results

Batches are asynchronous by design. Create Batch returns a batch id and a status, not the completions. Poll with Groq: Get Batch on a later scheduled run until it reports the output file id, then read the results with Groq: Download File Content. The completion window you set on the batch is the outer bound for how long that can take.

There is no node for the endpoint you need

Some gaps are deliberate and some are Groq's. File upload needs a binary multipart payload the canvas config panel cannot produce, so upload the JSONL or adapter archive out of band and bring the file id into the workflow; the read, download, and delete nodes cover the rest of the lifecycle. Text to speech returns raw audio rather than JSON and is not shipped. Streaming is not exposed, and the connector strips stream from outbound bodies so a pasted OpenAI payload cannot silently break a node. Groq itself documents no embeddings endpoint and no model delete, so no node can exist for either.

The Groq MCP

What connecting Groq 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.

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