# https://console.groq.com llms.txt

- [JigsawStack 🧩](https://console.groq.com/docs/jigsawstack): The JigsawStack 🧩 documentation page provides an overview of the AI SDK, detailing its capabilities in automating tasks such as web scraping, OCR, and translation using Large Language Models (LLMs), as well as its features like the Prompt Engine and built-in safety guardrails. This page serves as a starting point for integrating JigsawStack into existing applications and learning about its key features and setup process.
- [Groq API Reference](https://console.groq.com/docs/api-reference): The Groq API Reference provides detailed information on the available APIs, endpoints, and parameters for interacting with Groq's services, enabling developers to integrate and utilize Groq's capabilities in their applications. This reference guide serves as a comprehensive resource for understanding and using the Groq API to build, deploy, and manage AI-driven solutions.
- [Parallel + Groq: Fast Web Search for Real-Time AI Research](https://console.groq.com/docs/parallel): This documentation page provides a guide on integrating Parallel's real-time web search capabilities with Groq's high-speed inference to build AI research agents that can quickly find and analyze current information. It offers a step-by-step quick start guide, code examples, and advanced use cases for applications such as multi-company comparisons, real-time market data retrieval, and breaking news monitoring.
- [Security Onboarding](https://console.groq.com/docs/production-readiness/security-onboarding): The "Security Onboarding" guide provides best practices and recommendations for securing API keys, client configurations, and integrations when using Groq's API, ensuring a secure and reliable experience. This page outlines shared security responsibilities between Groq and customers, covering key management, transport security, input safety, and incident response.
- [Production-Ready Checklist for Applications on GroqCloud](https://console.groq.com/docs/production-readiness/production-ready-checklist): The "Production-Ready Checklist for Applications on GroqCloud" provides a comprehensive guide for deploying and scaling LLM applications on GroqCloud, covering critical aspects such as model selection, performance optimization, monitoring, and cost management. This checklist helps developers ensure their Groq-powered applications are launched and scaled with confidence, minimizing common pitfalls and optimizing user experience, operational costs, and system reliability.
- [Understanding and Optimizing Latency on Groq](https://console.groq.com/docs/production-readiness/optimizing-latency): This guide provides a comprehensive overview of latency in Groq-powered applications, helping developers understand, measure, and optimize latency for production deployment. It covers key metrics, factors affecting latency, and optimization strategies for building efficient Large Language Model (LLM) applications on Groq.
- [Anchor Browser + Groq: Blazing Fast Browser Agents](https://console.groq.com/docs/anchorbrowser): This documentation page provides a quickstart guide on using Anchor Browser with Groq to create blazing-fast browser agents for automating web interactions, such as data collection, using AI-powered browser automation. It covers prerequisites, setup, and example code for extracting data from websites and advanced session configuration.
- [Mcp: Page (mdx)](https://console.groq.com/docs/mcp): The Mcp: Page (mdx) documentation page provides information on utilizing the MDX page component within the MCP framework. This page serves as a resource for developers looking to implement and customize MDX pages.
- [Compound Mini: Page (mdx)](https://console.groq.com/docs/agentic-tooling/groq/compound-mini): The Compound Mini: Page (mdx) component is a MarkdownX (MDX) page template used for creating mini pages within the Compound application. This page template is designed to display concise content, but currently, no content is available to display.
- [Compound: Page (mdx)](https://console.groq.com/docs/agentic-tooling/groq/compound): The Page compound is a basic building block for creating content pages in MDX format. It serves as a container for page content, providing a structured layout for displaying text, images, and other media.
- [Compound Beta Mini: Page (mdx)](https://console.groq.com/docs/agentic-tooling/compound-beta-mini): The Compound Beta Mini: Page (mdx) documentation provides information on utilizing the MDX page component within the Compound Beta Mini framework. This page serves as a resource for developers integrating or customizing the page element in their applications.
- [Compound Beta: Page (mdx)](https://console.groq.com/docs/agentic-tooling/compound-beta): The Compound Beta: Page (mdx) documentation provides information on utilizing Markdown extensions (MDX) to create and customize pages within the Compound Beta framework. This page serves as a resource for developers looking to leverage MDX for page creation.
- [Agentic Tooling: Page (mdx)](https://console.groq.com/docs/agentic-tooling): This page provides information on utilizing Agentic Tooling with Markdown extensions (MDX) to create interactive and dynamic content. It serves as a resource for developers looking to integrate agentic capabilities into their MDX pages.
- [Spend Limits](https://console.groq.com/docs/spend-limits): The Spend Limits page provides information on how to control API costs by setting automated spending limits and receiving proactive usage alerts when approaching budget thresholds. This feature allows users to manage their API expenses by blocking access when a monthly cap is reached and sending notifications via email to prevent unexpected costs.
- [Projects](https://console.groq.com/docs/projects): The "Projects" page provides a framework for managing multiple applications, environments, and teams within a single Groq account, enabling organizations to isolate workloads and gain granular control over resources, costs, and access permissions. This page guides users in creating and managing projects to organize their work, track spending, and collaborate with teams.
- [Your Data in GroqCloud](https://console.groq.com/docs/your-data): This page provides information on how Groq handles customer data in GroqCloud, including the types of data retained, circumstances for retention, and available controls. It helps users understand and manage data retention settings through the Data Controls settings.
- [xRx + Groq: Easily Build Rich Multi-Modal Experiences](https://console.groq.com/docs/xrx): This documentation page provides a guide on how to use xRx, an open-source framework, in conjunction with Groq to build rich multi-modal experiences, enabling developers to create sophisticated AI systems that integrate text, voice, and other interaction forms. The page offers a quick start guide, including step-by-step instructions and example applications, to help developers get started with building their own multi-modal AI-powered applications.
- [Agno + Groq: Fast Agents](https://console.groq.com/docs/agno): This documentation page provides a guide on building fast agents using Agno and Groq, enabling the creation of multi-modal agents that can perform tasks such as searching knowledge stores, understanding images, and generating structured outputs. It offers a Python quick start tutorial and examples for building simple agents and multi-agent teams.
- [Prompt Engineering Patterns Guide](https://console.groq.com/docs/prompting/patterns): The "Prompt Engineering Patterns Guide" provides a systematic approach to selecting effective prompt patterns for various tasks when working with open-source language models, ensuring improved output reliability and performance. This guide helps users choose the optimal prompt pattern for their specific task, covering a range of applications from simple Q&A to complex reasoning and accuracy-critical tasks.
- [Model Migration Guide](https://console.groq.com/docs/prompting/model-migration): The Model Migration Guide provides a comprehensive framework for transitioning prompts from commercial models to open-source ones like Llama, focusing on adjusting prompting techniques, matching generation parameters, and testing outputs. This guide outlines key principles and strategies for ensuring a smooth migration, including refactoring prompts, aligning system behavior and tone, and achieving sampling and parameter parity.
- [Prompt Basics](https://console.groq.com/docs/prompting): The "Prompt Basics" guide provides fundamental principles for crafting effective prompts for open-source instruction-tuned large language models, enabling users to communicate clear instructions and expectations. This guide covers essential concepts, including prompt building blocks, role channels, and best practices for optimizing prompt quality and model output.
- [Arize + Groq: Open-Source AI Observability](https://console.groq.com/docs/arize): This documentation page provides a guide on integrating Arize Phoenix, an open-source AI observability library, with Groq-powered applications to gain deep insights into LLM workflow performance and behavior. It outlines the features and steps to set up automatic tracing, real-time monitoring, and evaluation frameworks for Groq applications using Arize Phoenix.
- [Coding With Groq: Recommended Models (tsx)](https://console.groq.com/docs/coding-with-groq/recommended-models): This page provides a list of recommended models for use with Groq, specifically for coding tasks. It highlights a powerful open-source model, openai/gpt-oss-120b, and offers a link to explore additional models available in the Groq model catalog.
- [Coding With Groq: Most Popular (tsx)](https://console.groq.com/docs/coding-with-groq/most-popular): This page lists the most popular tools and resources for getting started with Groq, including autonomous engineering agents and AI coding tools. It provides an overview of popular solutions like Factory Droid and OpenCode that integrate with Groq's low-latency inference capabilities.
- [Coding with Groq](https://console.groq.com/docs/coding-with-groq): This page provides information on integrating Groq's fast inference capabilities into various coding tools and environments. It serves as a resource for developers looking to leverage Groq's performance in their coding workflows.
- [Kilo Code + Groq](https://console.groq.com/docs/coding-with-groq/kilo-code): This documentation page provides instructions on integrating Kilo Code, an AI-powered coding assistant, with Groq's LPU inference for ultra-fast response times in interactive development workflows. It guides users through the prerequisites, setup, and configuration required to pair Kilo Code with Groq's native provider support.
- [OpenCode + Groq](https://console.groq.com/docs/coding-with-groq/opencode): This page provides instructions on integrating OpenCode, an open-source AI coding agent, with Groq's LPU inference for low-latency code generation. It guides users through the setup process, including configuring the Groq provider and selecting compatible models for optimal performance.
- [Factory Droid + Groq](https://console.groq.com/docs/coding-with-groq/factory-droid): This documentation page provides instructions on integrating Factory Droid, an autonomous engineering agent, with Groq's LPU inference for low-latency code generation while maintaining on-device API key security via Bring Your Own Key (BYOK). It guides users through the setup process, prerequisites, and recommended configurations for using Factory Droid with Groq.
- [Coding With Groq: More Tools (tsx)](https://console.groq.com/docs/coding-with-groq/more-tools): This page provides an overview of additional tools that integrate with Groq, helping developers streamline their workflow. It lists various AI-powered coding assistants that offer native Groq provider support for popular IDEs and platforms.
- [Cline + Groq](https://console.groq.com/docs/coding-with-groq/cline): This documentation page provides instructions on integrating Cline, a powerful CLI tool and AI coding assistant, with Groq's LPU inference for ultra-fast response times in interactive development workflows. It outlines the prerequisites, setup process, and recommended Groq models for using Cline with native Groq provider support.
- [Roo Code + Groq](https://console.groq.com/docs/coding-with-groq/roo-code): This documentation page provides instructions on integrating Roo Code, an AI-powered coding assistant, with Groq's LPU inference for ultra-fast response times in interactive development workflows. It outlines the prerequisites, setup process, and recommended Groq models for using Roo Code with native Groq provider support.
- [Overview Refresh: Page (mdx)](https://console.groq.com/docs/overview-refresh): The "Overview Refresh: Page (mdx)" page serves as a template or placeholder for overview refresh content, but currently, there is no content to display. This page likely intends to provide an overview or summary of refresh-related information, which will be populated in the future.
- [API Error Codes and Responses](https://console.groq.com/docs/errors): This documentation page provides information on the API error codes and responses used by our API, including standard HTTP response status codes and detailed error messages. It outlines the various error codes, their descriptions, and example response bodies to help users troubleshoot and understand API request failures.
- [EchoKit + Groq: Full-Stack AI Voice Solutions](https://console.groq.com/docs/echokit): This documentation page provides a comprehensive guide to integrating EchoKit, a full-stack open-source AI solution, with Groq's fast inference capabilities to build responsive voice AI applications with minimal latency. It covers key features, configuration examples, and quick start instructions for setting up a full-stack AI voice solution using EchoKit and Groq.
- [Assistant Message Prefilling](https://console.groq.com/docs/prefilling): This page provides information on Assistant Message Prefilling, a technique used with Groq API to control model output by prefilling `assistant` messages and directing text-to-text models. It explains how to prefill assistant messages to skip introductions, enforce output formats, and maintain conversation consistency.
- [Groq Client Libraries](https://console.groq.com/docs/libraries): The Groq Client Libraries page provides information on the official Python and JavaScript/TypeScript client libraries for accessing the Groq REST API, as well as community-developed libraries for other programming languages. These libraries offer convenient access to the Groq API, including type definitions and synchronous/asynchronous clients.
- [BrowserBase + Groq: Scalable Browser Automation with AI](https://console.groq.com/docs/browserbase): This documentation page explains how to integrate BrowserBase, a cloud-based headless browser infrastructure, with Groq's AI capabilities to enable scalable browser automation using natural language instructions. It provides a guide on setting up the integration and showcases example use cases for automating browser actions, such as multi-step workflows, e-commerce price monitoring, and form automation.
- [LiveKit + Groq: Build End-to-End AI Voice Applications](https://console.groq.com/docs/livekit): This documentation page provides a guide on integrating LiveKit with Groq to build end-to-end AI voice applications, combining speech recognition, text-to-speech, and real-time communication features. It offers a step-by-step tutorial on setting up a voice agent using LiveKit and Groq, enabling developers to create scalable voice applications with multi-user interactions.
- [Speech to Text](https://console.groq.com/docs/speech-to-text): The "Speech to Text" documentation page provides an overview of the Groq API's speech-to-text solution, offering OpenAI-compatible endpoints for near-instant transcriptions and translations. This page guides developers on integrating high-quality audio processing into their applications using the API's endpoints, supported models, and audio file limitations.
- [Browser Use + Groq: Intelligent Web Research & Product Comparison](https://console.groq.com/docs/browseruse): This documentation page provides instructions and examples for integrating Browser Use and Groq to build intelligent web research agents that can autonomously browse the web, extract information, and compare products across multiple sources. It guides developers through setting up the required packages, API keys, and creating research agents that can deliver comprehensive insights in seconds.
- [Quickstart](https://console.groq.com/docs/quickstart): The Quickstart page provides a step-by-step guide to getting started with the Groq API, covering key setup, authentication, and example usage in various programming languages and frameworks. This page helps users quickly set up and integrate the Groq API into their applications, with additional resources for further support.
- [Images and Vision](https://console.groq.com/docs/vision): The "Images and Vision" documentation page provides guidance on using the Groq API's multimodal models to analyze and interpret visual data from images, enabling applications such as visual question answering, caption generation, and Optical Character Recognition (OCR). This page offers tutorials, code examples, and use cases for integrating vision capabilities into applications using the Groq API.
- [Built-in Tools](https://console.groq.com/docs/compound/built-in-tools): The "Built-in Tools" page provides an overview of the comprehensive set of tools that come equipped with Compound systems, enabling users to access real-time information, computational power, and interactive environments. This page details the default and available tools, their configurations, and usage guidelines for Compound system users.
- [Compound](https://console.groq.com/docs/compound): The Compound documentation page provides information on advanced AI systems that solve problems by taking action and intelligently using external tools, such as web search and code execution, alongside powerful large language models. This page details the capabilities, available Compound systems, and usage guidelines for integrating these systems into applications.
- [Key Technical Specifications](https://console.groq.com/docs/compound/systems/compound-mini): The "Key Technical Specifications" page provides an overview of the technical capabilities and performance metrics of the Compound Mini system, a unified AI model that integrates Llama 3.3 70B and GPT-OSS 120B with external tools like web search and code execution. This page details key specifications, use cases, best practices, and limitations to help developers understand and effectively utilize the Compound Mini system.
- [Key Technical Specifications](https://console.groq.com/docs/compound/systems/compound): This documentation page provides an overview of the key technical specifications for Compound, a model powered by Llama 4 Scout and GPT-OSS 120B for intelligent reasoning and tool use. It outlines the model's architecture, performance metrics, use cases, best practices, and more to help users understand and effectively utilize Compound's capabilities.
- [Compound Beta Mini: Page (mdx)](https://console.groq.com/docs/compound/systems/compound-beta-mini): The Compound Beta Mini: Page (mdx) documentation provides information on utilizing the MDX page type within the Compound Beta Mini framework. This page currently does not have any specific content or details to display.
- [Compound Beta: Page (mdx)](https://console.groq.com/docs/compound/systems/compound-beta): The Compound Beta: Page (mdx) documentation provides information on utilizing Markdown extensions (MDX) to create and customize pages within the Compound Beta framework. This page serves as a resource for developers looking to leverage MDX for page creation.
- [Systems](https://console.groq.com/docs/compound/systems): This documentation page provides an overview of Groq's compound AI systems, including the Compound and Compound Mini models, which utilize external tools to enhance response accuracy and capability. The page details the features, use cases, and differences between these two systems, helping users choose the most suitable option for their specific needs.
- [Use Cases](https://console.groq.com/docs/compound/use-cases): This page provides an overview of various use cases for Groq's compound systems, highlighting their capabilities in handling real-time information and complex tasks. It showcases solutions for applications such as real-time fact checking, chart generation, natural language calculation, and code debugging.
- [Search Settings: Page (mdx)](https://console.groq.com/docs/compound/search-settings): The "Search Settings: Page (mdx)" documentation page provides information on configuring search settings for MDX pages. This page is currently not populated with content, but is intended to guide users on customizing search functionality for their MDX pages.
- [Tavily + Groq: Real-Time Search, Scraping & Crawling for AI](https://console.groq.com/docs/tavily): This documentation page provides a guide on integrating Tavily's real-time search, scraping, and crawling API with Groq's ultra-fast inference to build intelligent agents that can research topics, monitor websites, and extract structured data. It offers a comprehensive overview of the combined capabilities, key features, and example use cases for leveraging Tavily and Groq to accelerate AI-driven data extraction and research tasks.
- [Changelog](https://console.groq.com/docs/legacy-changelog): The Groq Changelog provides a chronological record of updates, releases, and developments to the Groq API, allowing users to track changes and stay informed about new features and models. This page lists updates in reverse chronological order, with the most recent changes appearing at the top.
- [OpenAI Compatibility](https://console.groq.com/docs/openai): This page provides information on the compatibility of Groq API with OpenAI's client libraries, allowing users to easily configure their existing OpenAI applications to run on Groq. It covers configuration, unsupported features, and additional resources for migrating to Groq's API.
- [AutoGen + Groq: Building Multi-Agent AI Applications](https://console.groq.com/docs/autogen): This documentation page provides a guide on building multi-agent AI applications using AutoGen and Groq, enabling developers to create sophisticated AI agents that collaborate to solve complex tasks quickly. It covers key features, including multi-agent orchestration, tool integration, and flexible workflows, along with code examples for getting started with the technology.
- [Text Generation](https://console.groq.com/docs/text-chat): This documentation page provides an overview and guides for using Groq's Chat Completions API for text generation, enabling natural conversational interactions with large language models. It covers various topics, including chat completions, getting started with the Groq SDK, and performing different types of chat completions, such as basic, streaming, and asynchronous completions.
- [🦜️🔗 LangChain + Groq](https://console.groq.com/docs/langchain): This documentation page provides a guide on integrating LangChain with Groq API to build sophisticated applications with Large Language Models (LLMs), leveraging fast inference speed and LangChain components. It offers a quick start tutorial on setting up the LangChain-Groq package and creating a simple LangChain assistant.
- [Responses API](https://console.groq.com/docs/responses-api): The Responses API provides a compatible interface with OpenAI's Responses API, enabling the integration of advanced conversational AI capabilities into applications with support for text and image inputs, stateful conversations, and function calling. This API allows developers to leverage Groq's AI models for various tasks, including text outputs, multi-turn conversations, and interactions with external systems.
- [Billing FAQs](https://console.groq.com/docs/billing-faqs): The "Billing FAQs" page provides answers to common questions about Groq's billing model, including upgrading to the Developer tier, understanding billing cycles, and progressive billing thresholds. This page helps users navigate the billing process, covering topics such as benefits of upgrading, downgrading, and special billing considerations for customers in India.
- [Structured Outputs](https://console.groq.com/docs/structured-outputs): This page provides information on Structured Outputs, a feature that ensures model responses conform to a provided JSON schema, guaranteeing reliable and type-safe data structures. It details two modes, Strict and Best-effort, which offer varying levels of schema adherence and requirements.
- [Mastra + Groq: Build Production AI Agents & Workflows](https://console.groq.com/docs/mastra): This documentation page provides a guide on integrating Mastra, a TypeScript framework for building production-ready AI applications, with Groq's fast inference to create sophisticated AI agents and workflows. It outlines the key features and capabilities of the combined solution, including agent frameworks, workflow engines, and observability tools.
- [MLflow + Groq: Open-Source GenAI Observability](https://console.groq.com/docs/mlflow): This documentation page provides a comprehensive guide on integrating MLflow with Groq to enable open-source observability for Generative AI (GenAI) applications, allowing users to track and monitor their interactions with Groq models. The page covers the key features of the integration, including tracing dashboards, automated tracing, and evaluation metrics, as well as a Python quick start guide to get started with MLflow and Groq.
- [🚅 LiteLLM + Groq for Production Deployments](https://console.groq.com/docs/litellm): This documentation page provides a guide on integrating LiteLLM with Groq for production deployments, enabling features such as cost management, smart caching, and spend tracking. It offers a quick start tutorial and next steps for configuring advanced features and building production-ready applications with LiteLLM and Groq.
- [CrewAI + Groq: High-Speed Agent Orchestration](https://console.groq.com/docs/crewai): This documentation page provides a guide on integrating CrewAI, a framework for orchestrating multiple AI agents, with Groq's high-speed inference capabilities to enable rapid autonomous decision-making and collaboration. It outlines the benefits and implementation details of using Groq with CrewAI for efficient agent communication and scalable multi-agent systems.
- [Composio](https://console.groq.com/docs/composio): This documentation page provides an overview and setup guide for Composio, a platform for integrating tools with LLMs and AI agents, enabling fast and secure interactions with external applications. It details how to build Groq-based assistants using Composio's features, including tool integration, authentication management, and optimized execution.
- [Prompt Caching](https://console.groq.com/docs/prompt-caching): This documentation page explains Prompt Caching, a feature that automatically reuses computation from recent API requests with shared prefixes to deliver cost savings and improved response times. It provides an overview of how prompt caching works, its benefits, and guidelines for structuring prompts to optimize caching.
- [How Groq Uses Your Feedback](https://console.groq.com/docs/feedback-policy): This page explains how Groq collects, reviews, and uses feedback provided by users through various channels, and how it is stored and retained in accordance with Groq's Privacy Policy. It outlines the types of feedback collected, the purposes for which it is used, and the procedures for reviewing and retaining feedback to improve product quality and safety.
- [Performance Tier](https://console.groq.com/docs/performance-tier): The Performance tier provides prioritized capacity for low, consistent latency, offering a 99.9% availability SLA and a 99% latency guarantee for enterprise plans. This tier is ideal for user-facing or production-critical paths where latency consistency matters most, and is delivered as provisioned throughput with pricing based on purchased input and output capacity bundles.
- [FlutterFlow + Groq: Fast & Powerful Cross-Platform Apps](https://console.groq.com/docs/flutterflow): This documentation page provides a guide on integrating FlutterFlow with Groq to build fast and powerful cross-platform apps with AI capabilities. It outlines the benefits of the integration and offers a step-by-step quick start guide to get started with building AI-powered apps using FlutterFlow and Groq.
- [Prometheus Metrics](https://console.groq.com/docs/prometheus-metrics): This documentation page provides information on accessing and utilizing Prometheus metrics for monitoring Groq's usage, specifically for Enterprise tier customers. It outlines the available metrics, APIs, and querying methods, including integration with Grafana and usage of MetricsQL.
- [Reasoning](https://console.groq.com/docs/reasoning): The "Reasoning" page provides information on utilizing reasoning models for complex problem-solving tasks that require step-by-step analysis and logical deduction. This page explains the importance of speed, supported models, and API parameters for controlling the reasoning format and inclusion in responses.
- [Overview](https://console.groq.com/docs/overview/content): The "Overview" page provides an introduction to Groq's API, highlighting its key features such as fast LLM inference, OpenAI compatibility, and ease of integration and scalability. This page serves as a starting point for developers to quickly get started with building applications on Groq.
- [Overview: Page (mdx)](https://console.groq.com/docs/overview): The "Page (mdx)" documentation page provides an overview of the MDX page component, outlining its purpose and functionality within the system. This page serves as a central resource for understanding the role and capabilities of MDX pages.
- [Code Execution](https://console.groq.com/docs/tool-use/built-in-tools/code-execution): This documentation page provides information on code execution capabilities in Groq, including supported models and systems, and how to use code execution to perform calculations and run code snippets. It outlines the native support for automatic code execution, currently limited to Python, and details usage guidelines and limitations.
- [Wolfram‑Alpha Integration](https://console.groq.com/docs/tool-use/built-in-tools/wolfram-alpha): The Wolfram‑Alpha Integration documentation page provides information on how to integrate Wolfram's computational knowledge engine with Groq models, enabling them to access precise calculations and structured knowledge for mathematical, scientific, and engineering computations. This page outlines the supported models, setup process, and usage examples for leveraging Wolfram‑Alpha integration in Groq applications.
- [Visit Website](https://console.groq.com/docs/tool-use/built-in-tools/visit-website): The "Visit Website" page provides documentation on how to use Groq's native support for visiting and analyzing specific websites, allowing models to retrieve and process content from publicly accessible websites. This feature enables detailed analysis based on actual page content and is supported for specific models, including Compound and Compound Mini.
- [Groq Built-In Tools](https://console.groq.com/docs/tool-use/built-in-tools): This page provides information on Groq Built-In Tools, which are server-side tools that enable agentic capabilities in applications with zero orchestration required. They allow developers to easily integrate tools like web search, code execution, and browser automation into their applications by making API calls and specifying allowed tools.
- [Browser Automation](https://console.groq.com/docs/tool-use/built-in-tools/browser-automation): This documentation page provides information on browser automation, a feature that enables certain Groq models to launch and control multiple browsers simultaneously to gather comprehensive information from various sources. The page covers supported models, setup instructions, and how browser automation works to facilitate parallel web research and deeper analysis.
- [Web Search: Countries (ts)](https://console.groq.com/docs/tool-use/built-in-tools/web-search/countries): The "Web Search: Countries (ts)" page provides a list of countries in TypeScript format, which can be used for web search functionality or data validation. This list includes all country names in lowercase, presented as a comma-separated string of template literals.
- [Web Search](https://console.groq.com/docs/tool-use/built-in-tools/web-search): The "Web Search" documentation page provides information on using native web search capabilities in Groq models and systems, allowing them to access real-time web content and provide up-to-date answers. This page explains the functionality, supported systems, and usage guidelines for web search, including customization options and output formats.
- [Browser Search](https://console.groq.com/docs/tool-use/built-in-tools/browser-search): The "Browser Search" documentation page provides information on using built-in browser search functionality with supported models on Groq, allowing for interactive web content access and more comprehensive search results. This page covers features, supported models, usage guidelines, and best practices for leveraging browser search capabilities.
- [Remote Tools and Model Context Protocol (MCP)](https://console.groq.com/docs/tool-use/remote-mcp): The Remote Tools and Model Context Protocol (MCP) documentation page provides an overview of the MCP standard, which enables AI applications to connect with external systems through a universal interface, and explains how to use remote MCP servers with Groq's API. This page guides users on leveraging MCP to simplify tool integration and usage with Groq's Responses API.
- [MCP Connectors](https://console.groq.com/docs/tool-use/remote-mcp/connectors): The MCP Connectors documentation page provides information on integrating with popular business applications, such as Google Workspace, using pre-built connectors that enable access to services like Gmail, Google Calendar, and Google Drive. This page outlines the available connectors, their authentication processes, and usage examples to facilitate seamless integration with MCP servers.
- [Tool Use: Page (mdx)](https://console.groq.com/docs/tool-use): The "Tool Use: Page (mdx)" documentation page provides information on utilizing MDX pages within the tool. This page serves as a resource for understanding the functionality and application of MDX pages.
- [Tool Use](https://console.groq.com/docs/tool-use/overview): This documentation page explains the concept of tool use, which enables applications using Large Language Models (LLMs) to interact with external resources and perform actions. It provides a detailed overview of how tool use works, including the process of defining tools, making tool calls, and executing tool functions.
- [Local Tool Calling](https://console.groq.com/docs/tool-use/local-tool-calling): The "Local Tool Calling" documentation page explains how to define and implement functions in your application code to execute tools locally, giving you complete control over tool execution and allowing integration with custom business logic, internal systems, and security-sensitive operations. This approach enables orchestration of tool calls and results within your application code, rather than relying on Groq's infrastructure.
- [Service Tiers](https://console.groq.com/docs/service-tiers): This page provides an overview of Groq's service tiers, which allow users to optimize for latency, throughput, and reliability by selecting from four tiers: performance, on_demand, flex, and auto. The service tiers can be specified using the `service_tier` parameter, except for batch and asynchronous workloads which operate under separate conditions.
- [E2B + Groq: Open-Source Code Interpreter](https://console.groq.com/docs/e2b): The E2B + Groq: Open-Source Code Interpreter documentation page provides a guide on using the E2B SDK to create secure, sandboxed environments for executing code generated by LLMs via the Groq API. This page offers a Python quick start tutorial, example code, and resources for building AI-driven data analysis applications with E2B and Groq.
- [Flex Processing](https://console.groq.com/docs/flex-processing): Flex Processing is a service tier designed for high-throughput workloads, prioritizing fast inference and handling occasional request failures with significantly higher rate limits at the same pricing as on-demand processing. This tier is available to paid customers, offering 10x higher rate limits compared to on-demand processing for select models.
- [HuggingFace + Groq: Real-Time Model & Dataset Discovery](https://console.groq.com/docs/huggingface): This documentation page provides instructions and examples for integrating HuggingFace's model and dataset repository with Groq's fast inference capabilities, enabling real-time discovery, analysis, and recommendations of AI models and datasets. By combining these technologies, users can build intelligent agents that access recently published resources and provide smart suggestions based on natural language queries.
- [Rate Limits](https://console.groq.com/docs/rate-limits): This documentation page explains rate limits, which regulate how frequently users and applications can access the API within specified timeframes to ensure service stability, fair access, and protection against misuse. It provides details on understanding, viewing, and handling rate limits, including limit types, headers, and response codes.
- [🗂️ LlamaIndex 🦙](https://console.groq.com/docs/llama-index): The LlamaIndex page provides an overview of the LlamaIndex framework, a data framework for LLM-based applications that enables context augmentation and safe injection of private or domain-specific data into LLMs. This page serves as a starting point for integrating LlamaIndex with Groq, with additional resources available for Python and JavaScript implementations.
- [Exa + Groq: AI-Powered Web Search & Content Discovery](https://console.groq.com/docs/exa): This documentation page provides a guide on integrating Exa, an AI-native search engine, with Groq's fast inference capabilities to build intelligent search applications that enable AI-powered web search and content discovery. It offers tutorials, code examples, and key features for utilizing Exa and Groq to create advanced search agents for tasks such as semantic understanding, company research, and content extraction.
- [Firecrawl + Groq: AI-Powered Web Scraping & Data Extraction](https://console.groq.com/docs/firecrawl): This documentation page provides a guide on integrating Firecrawl, an enterprise-grade web scraping platform, with Groq's fast inference capabilities to build intelligent agents for scraping websites, extracting structured data, and conducting deep research. The page offers a quick start guide, code examples, and advanced use cases for AI-powered web scraping and data extraction using Firecrawl and Groq.
- [LoRA Inference on Groq](https://console.groq.com/docs/lora): This documentation page provides information on running LoRA (Low-Rank Adaptation) inference on Groq's infrastructure, a parameter-efficient fine-tuning technique that allows for customized model behavior without altering base model weights. The page explains the benefits, features, and deployment options of LoRA on Groq, specifically for enterprise-tier customers.
- [Model Permissions](https://console.groq.com/docs/model-permissions): This page provides information on configuring model permissions to limit which models can be used at the organization and project level, allowing for fine-grained control over model access. Model permissions can be set using "Only Allow" or "Only Block" strategies to either allow or block specific models.
- [Google Cloud Private Service Connect](https://console.groq.com/docs/security/gcp-private-service-connect): This page provides a guide on setting up Google Cloud Private Service Connect (PSC) to securely access Groq's API services through private network connections, eliminating exposure to the public internet. It outlines the overview, prerequisites, and step-by-step setup process for configuring PSC endpoints.
- [🎨 Gradio + Groq: Easily Build Web Interfaces](https://console.groq.com/docs/gradio): This documentation page provides a guide on integrating Gradio with Groq to easily build web interfaces for Groq applications, enabling the creation of interactive demos and shareable apps. It offers a quick start tutorial and resources for building robust, multimodal applications with Gradio and Groq.
- [✨ Vercel AI SDK + Groq: Rapid App Development](https://console.groq.com/docs/ai-sdk): This documentation page provides a comprehensive guide on integrating Vercel's AI SDK with Groq for rapid application development, enabling developers to leverage powerful language models for various applications. It offers a step-by-step quick start guide in JavaScript to deploy a scalable and high-speed application within minutes.
- [Content Moderation](https://console.groq.com/docs/content-moderation): This documentation page provides an overview of content moderation, a crucial process that detects and filters harmful or unwanted content in user prompts and model responses to ensure safe and responsible use of models. It also introduces various content moderation models offered by Groq, including policy-following and prebaked safety models.
- [Models: Featured Cards (tsx)](https://console.groq.com/docs/models/featured-cards): This page provides an overview of featured cards showcasing various AI systems, including their capabilities, modalities, and performance metrics. The featured cards include Groq Compound and OpenAI GPT-OSS 120B, highlighting their unique features and specifications.
- [Models: Models (tsx)](https://console.groq.com/docs/models/models): This page provides detailed information about the available models, including their specifications, pricing, and rate limits. It lists various models, their speeds, and other relevant details such as context window, max completion tokens, and max file size.
- [Supported Models](https://console.groq.com/docs/models): The "Supported Models" page provides an overview of available models on GroqCloud, categorized into production models, preview models, and deprecated models, to help users choose the right model for their needs. This page also offers code examples and API endpoints to access and retrieve a list of all active models.
- [Key Technical Specifications](https://console.groq.com/docs/model/gemma2-9b-it): This page provides an overview of the key technical specifications for the Gemma 2 9B IT model, including its architecture, performance metrics, and best practices for use. It outlines essential details for developers and researchers to understand the model's capabilities and optimize its application in various use cases.
- [Llama Guard 4 12b: Page (mdx)](https://console.groq.com/docs/model/llama-guard-4-12b): The Llama Guard 4 12b page provides information and guidelines for utilizing the Llama Guard 4 12b model, a safety classifier designed to detect and filter out potentially harmful content. This page serves as a resource for developers and users to understand the capabilities and implementation of the Llama Guard 4 12b model.
- [Qwen3 32b: Page (mdx)](https://console.groq.com/docs/model/qwen3-32b): The Qwen3 32b page provides information and documentation for the Qwen3 32b model, but currently does not have any content available. This page is intended to serve as a resource for users seeking details about the Qwen3 32b model.
- [Llama 3.1 8b Instant: Model (tsx)](https://console.groq.com/docs/model/llama-3.1-8b-instant): The Llama 3.1 8b Instant model on Groq provides rapid response times with production-grade reliability, making it suitable for latency-sensitive applications. This model balances efficiency and performance for use cases such as chat interfaces, content filtering systems, and large-scale data processing workloads.
- [Qwen 2.5 Coder 32b: Model (tsx)](https://console.groq.com/docs/model/qwen-2.5-coder-32b): The Qwen 2.5 Coder 32b model is a specialized AI model fine-tuned for code generation and development tasks, built on 5.5 trillion tokens of code and technical content. This model delivers instant, production-quality code generation capabilities comparable to GPT-4.
- [Key Technical Specifications](https://console.groq.com/docs/model/whisper-large-v3-turbo): This documentation page provides key technical specifications and model details for the Whisper Large v3 Turbo speech-to-text model, highlighting its optimized architecture for speed, performance metrics, and use cases. It outlines the model's capabilities, including multilingual support, real-time transcription, and cost-effective solutions for various applications.
- [Mistral Saba 24b: Model (tsx)](https://console.groq.com/docs/model/mistral-saba-24b): This page provides details about the Mistral Saba 24b model, a specialized multilingual model optimized for Arabic, Farsi, Urdu, Hebrew, and Indic languages. The model features a 32K token context window and tool use capabilities, enabling strong performance across various languages.
- [Key Technical Specifications](https://console.groq.com/docs/model/moonshotai/kimi-k2-instruct-0905): This documentation page provides key technical specifications for the Kimi-K2-Instruct-0905 model, including its model architecture, performance metrics, and best practices for various use cases. It outlines the model's capabilities and guidelines for leveraging its features in applications such as frontend development, agent scaffolds, tool calling, and full-stack development.
- [Kimi K2 Version](https://console.groq.com/docs/model/moonshotai/kimi-k2-instruct): The Kimi K2 Version page provides information on the technical specifications, use cases, and best practices for the Kimi K2 model, which currently redirects to the latest 0905 version offering improved performance and capabilities. This page serves as a documentation hub for developers and users to understand the features and applications of the Kimi K2 model.
- [Llama Prompt Guard 2 22m: Page (mdx)](https://console.groq.com/docs/model/llama-prompt-guard-2-22m): The Llama Prompt Guard 2 22m page provides information on safeguarding prompts for the Llama model. This page currently does not contain any relevant information.
- [Deepseek R1 Distill Qwen 32b: Model (tsx)](https://console.groq.com/docs/model/deepseek-r1-distill-qwen-32b): The Deepseek R1 Distill Qwen 32b model page provides information on a distilled version of DeepSeek's R1 model, fine-tuned from the Qwen-2.5-32B base model, which delivers exceptional performance on mathematical and logical reasoning tasks. This page details the model's key features, performance, and use cases, including complex problem-solving and near-o1 level capabilities with faster response times.
- [Qwen3 32b: Model (tsx)](https://console.groq.com/docs/model/qwen/qwen3-32b): The Qwen3 32b model page provides information on the latest generation of large language models in the Qwen series, offering advancements in reasoning, instruction-following, and multilingual support. This page details the capabilities of the Qwen 3 32B model, including its unique ability to switch between thinking and non-thinking modes.
- [Llama 3.3 70b Versatile: Model (tsx)](https://console.groq.com/docs/model/llama-3.3-70b-versatile): This page provides information about the Llama 3.3 70b Versatile model, a multilingual large language model with 70 billion parameters optimized for various natural language processing tasks. It details the model's capabilities, performance, and applications.
- [Key Technical Specifications](https://console.groq.com/docs/model/playai-tts): The "Key Technical Specifications" page provides an overview of the PlayAI Dialog v1.0 model, including its architecture, training data, and use cases, to help developers understand its capabilities and limitations. This page serves as a central resource for technical details, best practices, and considerations for using the model in various applications.
- [Deepseek R1 Distill Llama 70b: Model (tsx)](https://console.groq.com/docs/model/deepseek-r1-distill-llama-70b): The Deepseek R1 Distill Llama 70b model page provides information on a distilled version of DeepSeek's R1 model, fine-tuned from the Llama-3.3-70B-Instruct base model for robust reasoning capabilities. This model delivers exceptional performance on mathematical and logical reasoning tasks with Groq's industry-leading speed.
- [Llama Prompt Guard 2 86m: Page (mdx)](https://console.groq.com/docs/model/llama-prompt-guard-2-86m): The Llama Prompt Guard 2 86m page provides information and guidelines for utilizing the Llama Prompt Guard 2 86m model, likely focusing on its application, configuration, and best practices. This page appears to be a documentation stub, awaiting additional content to support users working with this AI model.
- [Key Technical Specifications](https://console.groq.com/docs/model/openai/gpt-oss-120b): This documentation page provides key technical specifications and use cases for the GPT-OSS 120B model, a Mixture-of-Experts (MoE) architecture with 120B total parameters and exceptional performance across various benchmarks. The page outlines the model's capabilities, best practices for utilization, and guides users on getting started with the model for applications such as agentic applications, research, and multilingual AI assistants.
- [Key Technical Specifications](https://console.groq.com/docs/model/openai/gpt-oss-safeguard-20b): This documentation page provides an overview of the key technical specifications for GPT-OSS-Safeguard 20B, a model designed for safety classification tasks with support for custom policy interpretation and transparent reasoning. The page covers model architecture, performance metrics, use cases, and best practices for implementing the model in various applications.
- [Key Technical Specifications](https://console.groq.com/docs/model/openai/gpt-oss-20b): This documentation page provides an overview of the key technical specifications, use cases, and best practices for the GPT-OSS 20B model, a Mixture-of-Experts (MoE) architecture with 20B total parameters. It serves as a reference for developers and users to understand the model's capabilities, performance metrics, and optimal deployment strategies.
- [Llama 4 Scout 17b 16e Instruct: Page (mdx)](https://console.groq.com/docs/model/llama-4-scout-17b-16e-instruct): The Llama 4 Scout 17b 16e Instruct page provides information and guidance on utilizing the Llama 4 Scout 17b 16e Instruct model for specific tasks. This page is currently under development or has not been populated with content yet.
- [Llama Guard 3 8b: Model (tsx)](https://console.groq.com/docs/model/llama-guard-3-8b): The Llama Guard 3 8b model, built on the Llama framework, is a specialized content moderation model designed to identify and filter potentially harmful content. This page provides information on utilizing the model with Groq's high-speed AI processing capabilities for content moderation applications.
- [Key Technical Specifications](https://console.groq.com/docs/model/meta-llama/llama-guard-4-12b): This documentation page provides key technical specifications and details for Llama-Guard-4-12B, a specialized multimodal content moderation model designed to identify and classify potentially harmful content. It outlines the model's architecture, performance metrics, use cases, and best practices for effective content moderation and AI safety applications.
- [Key Technical Specifications](https://console.groq.com/docs/model/meta-llama/llama-prompt-guard-2-22m): This documentation page provides an overview of the key technical specifications and use cases for Llama Prompt Guard 2, a model designed to detect and prevent malicious prompt attacks on LLM applications. It outlines the model's architecture, performance metrics, best practices for implementation, and integration with existing safety measures to enhance LLM security.
- [Key Technical Specifications](https://console.groq.com/docs/model/meta-llama/llama-prompt-guard-2-86m): This documentation page provides key technical specifications and usage guidelines for Llama Prompt Guard 2, a model designed to detect and prevent malicious prompt attacks on LLM applications. It outlines the model's architecture, performance metrics, and best practices for implementation and security layering.
- [Llama 4 Scout 17b 16e Instruct: Model (tsx)](https://console.groq.com/docs/model/meta-llama/llama-4-scout-17b-16e-instruct): The Llama 4 Scout 17b 16e Instruct model page provides information on Meta's 17 billion parameter mixture-of-experts model, featuring native multimodality for text and image understanding, instruction-tuned for tasks like chat, visual reasoning, and coding. This page offers details on utilizing the model on Groq for industry-leading inference speed.
- [Llama 4 Maverick 17b 128e Instruct: Model (tsx)](https://console.groq.com/docs/model/meta-llama/llama-4-maverick-17b-128e-instruct): The Llama 4 Maverick 17b 128e Instruct model page provides an overview of Meta's 17 billion parameter mixture-of-experts model, featuring native multimodality for text and image understanding, instruction-tuned for tasks like chat, visual reasoning, and coding. This page details the model's key features, including its 128K token context length and industry-leading inference speed on Groq hardware.
- [Llama 3.3 70b Specdec: Model (tsx)](https://console.groq.com/docs/model/llama-3.3-70b-specdec): The Llama 3.3 70b Specdec model is Groq's speculative decoding version of Meta's Llama 3.3 70B model, optimized for high-speed inference while maintaining high quality. This model delivers exceptional performance with significantly reduced latency, making it ideal for real-time applications.
- [Llama3 70b 8192: Model (tsx)](https://console.groq.com/docs/model/llama3-70b-8192): This page provides documentation for the Llama3 70b 8192 model, a production-ready foundation model optimized for dialogue and content-generation tasks. The model offers a balance of performance and speed, delivering fast and consistent outputs through the Groq API.
- [Llama 3.2 1b Preview: Model (tsx)](https://console.groq.com/docs/model/llama-3.2-1b-preview): The Llama 3.2 1b Preview model page provides information on a fast and cost-effective language model with 1.23 billion parameters, suitable for high-throughput applications such as text analysis, information retrieval, and content summarization. This page details the model's capabilities, including its 128K context window, speed, accuracy, and use cases for rapid prototyping and content processing.
- [Key Technical Specifications](https://console.groq.com/docs/model/whisper-large-v3): This documentation page provides key technical specifications and details for the Whisper Large v3 model, including its architecture, performance metrics, and usage guidelines for various applications. It outlines the model's capabilities, such as high-accuracy transcription, multilingual support, and handling challenging audio conditions, to help users effectively utilize the model for their speech-to-text needs.
- [Key Technical Specifications](https://console.groq.com/docs/model/allam-2-7b): This documentation page provides key technical specifications, use cases, and best practices for the ALLaM-2-7B model, a bilingual Arabic-English autoregressive transformer designed for advanced language applications. It outlines the model's architecture, performance metrics, and guidelines for leveraging its capabilities in Arabic language technology, research, and development.
- [Llama3 8b 8192: Model (tsx)](https://console.groq.com/docs/model/llama3-8b-8192): This page provides documentation for the Llama3 8b 8192 model, specifically its integration and usage on Groq hardware. The Llama-3-8B-8192 model delivers exceptional performance with industry-leading speed and cost-efficiency.
- [Qwen Qwq 32b: Model (tsx)](https://console.groq.com/docs/model/qwen-qwq-32b): The Qwen Qwq 32b model page provides information on a 32-billion parameter reasoning model, deployed on Groq's hardware, which delivers competitive performance and the world's fastest reasoning. This page details the model's key features, including its performance, speed, and technical specifications.
- [Qwen 2.5 32b: Model (tsx)](https://console.groq.com/docs/model/qwen-2.5-32b): This page provides information about the Qwen 2.5 32b model, a flagship AI model developed by Alibaba with GPT-4 level capabilities. The page details the model's key features, including its performance in creative writing and complex reasoning tasks, as well as its availability for use on the Groq Hosted AI Models website.
- [Key Technical Specifications](https://console.groq.com/docs/model/canopylabs/orpheus-v1-english): This documentation page outlines the key technical specifications and best practices for using the Orpheus V1 English text-to-speech model, including its unique vocal direction features and various use cases. It provides guidance on how to effectively utilize the model for different applications, such as customer support, game characters, professional narration, and content creation.
- [Key Technical Specifications](https://console.groq.com/docs/model/canopylabs/orpheus-arabic-saudi): This page provides key technical specifications for the Orpheus Arabic Saudi text-to-speech model, including its architecture, language support, and performance features. It outlines the model's capabilities, such as authentic Saudi dialect pronunciation and low-latency inference, to help users understand its technical details and applications.
- [Key Technical Specifications](https://console.groq.com/docs/model/distil-whisper-large-v3-en): This documentation page provides key technical specifications and details for Distil-Whisper Large v3, a speech-to-text model built on the encoder-decoder transformer architecture, highlighting its performance metrics, model details, and best practices for usage. The page outlines the model's capabilities, use cases, and optimization strategies for real-time transcription, content processing, and interactive applications.
- [Llama 4 Maverick 17b 128e Instruct: Page (mdx)](https://console.groq.com/docs/model/llama-4-maverick-17b-128e-instruct): The Llama 4 Maverick 17b 128e Instruct page provides information and documentation for the specified model, likely including its architecture, training data, and usage guidelines. This page serves as a central resource for developers and researchers working with this particular AI model.
- [Llama 3.2 3b Preview: Model (tsx)](https://console.groq.com/docs/model/llama-3.2-3b-preview): The Llama 3.2 3b Preview model page provides details on a fast and balanced AI model with 3.1 billion parameters, suitable for tasks like content creation, summarization, and information retrieval. This page offers technical information on the model's capabilities, performance, and applications, including its efficient design for cost-effective real-time use cases.
- [Key Technical Specifications](https://console.groq.com/docs/model/playai-tts-arabic): This documentation page provides an overview of the key technical specifications for a text-to-speech model, including its architecture, training data, and use cases. It outlines the model's capabilities, best practices for implementation, and important considerations regarding limitations, bias, and ethical usage.
- [Groq Batch API](https://console.groq.com/docs/batch): The Groq Batch API enables large-scale asynchronous processing of API requests, allowing users to submit batches of requests for processing within a 24-hour to 7-day window at a 50% cost discount compared to synchronous APIs. This API is ideal for use cases that don't require immediate responses, such as processing large datasets, generating content in bulk, and running evaluations.
- [Toolhouse 🛠️🏠](https://console.groq.com/docs/toolhouse): The Toolhouse documentation page provides a comprehensive guide on using Toolhouse, a Backend-as-a-Service for the agentic stack, to build conversational and autonomous agents with ease. This page specifically focuses on integrating Toolhouse with Groq's fast inference, Llama 4 models, and Compound Beta to create and deploy agents as APIs.
- [Integrations: Button Group (tsx)](https://console.groq.com/docs/integrations/button-group): The Button Group integration provides a customizable component for displaying a group of buttons, typically used to showcase integration options. This component allows for an array of buttons with configurable properties, such as title, description, and icon, to be grouped together.
- [Integrations: Integration Buttons (ts)](https://console.groq.com/docs/integrations/integration-buttons): This page documents the integration buttons for various categories, including AI agent frameworks, browser automation, and LLM app development. It provides a list of integration groups and their corresponding buttons, each with details such as title, description, and icon.
- [What are integrations?](https://console.groq.com/docs/integrations): This documentation page explains what integrations are and how they can be used to connect Groq-powered applications to external services, enhancing their capabilities. It provides an overview of available integration categories to help users find suitable solutions for their needs.
- [Orpheus Text to Speech](https://console.groq.com/docs/text-to-speech/orpheus): The Orpheus Text to Speech page provides information on generating expressive, natural-sounding speech using Canopy Labs' Orpheus models, which offer fast and high-quality audio generation with unique expressive capabilities. This documentation covers the supported models, pricing, API endpoints, and usage examples for integrating text-to-speech functionality into applications.
- [Text to Speech](https://console.groq.com/docs/text-to-speech): The "Text to Speech" documentation page provides an overview of the Groq API's text-to-speech capabilities, enabling users to convert text into lifelike spoken audio. This page guides users on how to utilize the API endpoint to generate high-quality audio content in English and Arabic voices.