Connecting Groq to n8n: the fastest AI inference on the market for your automations

Groq occupies an unusual niche among LLM providers: the company isn't trying to ship the smartest model, it's trying to run the best open models (Llama chief among them) on hardware built for one thing — answering fast. Its LPU (Language Processing Unit), a chip dedicated to inference rather than training, delivers generation throughput well above what you get on a regular GPU, at a per-token cost among the lowest on the market. For an n8n workflow, that speed-plus-price combination unlocks use cases that slower providers simply make impractical: real-time conversational agents, voice callbots, very high-volume email triage. This guide shows how to connect Groq to n8n through the native node or the OpenAI-compatible API, and where that speed genuinely changes the equation.

Why Groq in an n8n workflow

Two arguments justify adding Groq to your toolbox, alongside your usual providers.

• Speed changes the user experience, not just comfort. A 2025 study published in the International Journal of Human–Computer Interaction (Kim et al., "From Seconds to Sentiments: Differential Effects of Chatbot Response Latency on Customer Evaluations" — see on Google Scholar) shows that a chatbot's response latency directly affects perceived user satisfaction and trust, with an especially strong effect once the response strays from the rhythm of a natural conversation. For a chatbot or an AI chat widget on your site, or worse for a voice agent answering the phone, every second of waiting at the LLM step lands directly on the experience — and Groq is precisely built to strip that particular link out of the latency chain.
• Specialized hardware changes the cost/speed equation. An academic survey of hardware acceleration for large language model inference (Li et al., "Large Language Model Inference Acceleration: A Comprehensive Hardware Perspective," arXiv 2024 — see on Google Scholar) places inference-dedicated chips like Groq's LPU among the architectures achieving the best throughput compared with general-purpose GPUs, precisely because they're built for a single job rather than for both training and inference. That specialization is what lets Groq offer very competitive per-token pricing on open models you could, in principle, run yourself.

For an n8n workflow, the practical translation is concrete: AI steps that took 3 or 4 seconds to answer on a general-purpose provider can answer in a fraction of a second on Groq, without changing the model (Llama stays Llama), just by switching hosts.

Creating the API key

1. Create an account at console.groq.com.
2. No credit card is needed to get started on the free tier — handy for testing before committing.
3. In the API Keys section, generate a key and copy it immediately.

As with any AI provider, store this key exclusively in n8n's credential manager, never hard-coded in a Code node — the right habits are covered in our guide to securing API credentials.

Method 1: the native Groq Chat Model node

n8n ships a built-in Groq Chat Model node (n8n-nodes-langchain.lmChatGroq). Like the other chat models, it's a LangChain sub-node: it doesn't run on its own, it plugs into a parent node — an AI Agent, an LLM Chain, a Text Classifier or an Information Extractor. If those building blocks are new to you, our guide to getting started with n8n's AI nodes lays the groundwork.

1. Add the parent node (an AI Agent, say), then attach a Groq Chat Model as its language model.
2. Create the credential with your Groq API key.
3. Pick the model from the list loaded dynamically from the Groq API (Meta's Llama models are the most common default choice; Groq also hosts other open models depending on current availability).

This is the method to prefer for any new workflow: a dedicated credential, cleanly exposed parameters, no URL tinkering.

Method 2: the OpenAI-compatible API (base URL or HTTP Request)

Groq's API is compatible with the OpenAI format. Two practical consequences:

• Repurposed OpenAI credential: create an OpenAI credential in n8n with your Groq key and replace the base URL with https://api.groq.com/openai/v1. Existing OpenAI nodes then work with Groq by typing the model name manually — useful for comparing Groq's latency on a workflow already wired for GPT or Claude without rewiring anything.
• HTTP Request node: for full control over parameters, call the endpoint directly:

POST https://api.groq.com/openai/v1/chat/completions
Authorization: Bearer {{ $credentials.apiKey }}
{
  "model": "llama-3.3-70b-versatile",
  "messages": [
    { "role": "system", "content": "Classify emails as: invoice, support, spam, other. Answer with a single word." },
    { "role": "user", "content": "{{ $json.emailBody }}" }
  ],
  "temperature": 0
}

A third route: go through OpenRouter, which lists Groq as one possible host among others for the same open models. You give up a little pricing margin and some raw latency, but you gain an instant failover to another host if Groq is saturated or unavailable.

A special case: audio transcription with Whisper

Groq also hosts Whisper models (speech recognition) on its LPU infrastructure, with transcription times noticeably shorter than on a regular run. If your workflows transcribe meetings or voice messages, it's worth testing alongside our guide to transcribing and summarizing meetings: same pipeline, same model, but a much faster round trip — a genuine advantage for anything that needs to feel "live."

Where Groq shines in n8n

Groq's natural fit is anywhere latency is visible:

• Voice agents and callbots: every LLM round trip stacks on top of speech recognition and speech synthesis; cutting that link down to a few hundred milliseconds changes how fluid an automated phone conversation feels.
• Real-time chatbots and chat widgets: on a site or app, a near-instant response time makes an exchange feel like a real conversation rather than a form that answers later.
• Very high-volume triage: sorting thousands of emails, tickets or customer reviews per day, both fast and cheap — the same ground covered by our Inbox AI Pack (€79), which can run on Groq models for its most frequent classification steps.
• The fast tier of a multi-provider cascade: Groq on the front line for simple cases, a slower but more capable model as backup for ambiguous ones — the pattern is detailed in our multi-provider fallback guide.

Limits and caution

Stay clear-eyed on two points before building a critical workflow on top of this.

Rotating model availability. Groq doesn't train its own models: it hosts open models, and its catalog shifts as new versions become available (Llama in particular changes generation regularly). A workflow that hard-codes a specific model name can break the day that model is retired from the catalog; check the list of active models in the Groq console before a production deployment, and plan a fallback model.

Limited throughput on the free tier. The free tier is generous for testing, but its requests-per-minute limits quickly become the bottleneck at real production volume. If your workflow scales up, move to a paid plan and monitor usage with the same rigor as for any other provider — our method for tracking AI call costs per workflow applies just as well to Groq as to OpenAI or Anthropic.

Key takeaways

• Create your key on console.groq.com (no credit card required to start) and store it in n8n's credential manager.
• Use the native Groq Chat Model node for new workflows, or the https://api.groq.com/openai/v1 base URL on an OpenAI credential to recycle existing ones.
• Reserve Groq for steps where latency is visible: voice agents, real-time chatbots, high-volume triage, or as the fast tier of a multi-provider cascade.
• Regularly check the list of active models and monitor rate limits before depending on Groq in production.