# Groq Models Scraper (`automation-lab/groq-models-scraper`) Actor 📊 Scrape all Groq LLM models with pricing, context window sizes, speed benchmarks, rate limits, and model IDs from the official Groq docs page. No API key required. - **URL**: https://apify.com/automation-lab/groq-models-scraper.md - **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community) - **Categories:** AI - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks - **User rating**: No ratings yet ## Pricing Pay per event This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Groq Models Scraper ### What does Groq Models Scraper do? **Groq Models Scraper** extracts the complete catalog of AI models available on [Groq](https://console.groq.com/docs/models) — no API key, no login, and no coding required. Run the actor and get structured data for every model including **pricing per million tokens, context window sizes, speed benchmarks, rate limits, and model IDs**. The actor fetches Groq's official models documentation page using a single HTTP request with Cheerio-based HTML parsing. No browser automation, no Playwright, no proxy required. Every model is returned as a clean JSON record ready to export to CSV, Google Sheets, or any downstream pipeline. Use this actor to monitor Groq model pricing changes, compare inference costs against other providers, or automate competitive analysis of fast-inference LLM platforms. --- ### Who is it for? **🤖 AI developers and backend engineers** - Find the exact model ID and current pricing before integrating Groq into your application - Verify context window sizes and rate limits for planning token budgets - Automate checks for new model releases or pricing changes **📊 ML researchers and data scientists** - Track Groq pricing trends over time by scheduling recurring runs - Compare inference speeds (tokens/sec) across models to choose the fastest for latency-sensitive apps - Build datasets for competitive pricing analysis across inference providers **💰 Cost optimization and FinOps teams** - Compare Groq input vs output token prices to optimize prompt engineering strategy - Monitor price changes across Llama, Gemma, Mistral, and Whisper models - Benchmark Groq rates against Together AI, Fireworks, DeepInfra, and other fast-inference providers **🏢 AI product managers and strategists** - Track which new models Groq adds to their platform - Monitor when models are deprecated or pricing structures change - Build dashboards comparing Groq's ultra-fast inference pricing to the broader market --- ### Why use Groq Models Scraper? - **No API key required** — Groq's models page is fully public - **Single HTTP request** — fetches all models in one call with zero JS rendering - **Zero proxy cost** — no browser automation or residential proxies needed - **Covers all model types** — text, audio (Whisper), speech synthesis (Orpheus), and agentic models - **Structured pricing fields** — separate fields for input price, output price, per-hour price, and per-character price - **Rate limits included** — tokens-per-minute and requests-per-minute for the developer plan - **Pay-per-event pricing** — pay only for models extracted, not idle compute time - **Schedule and automate** — run daily or weekly to track pricing and model changes over time - **Export anywhere** — JSON, CSV, Excel, Google Sheets, or push via API and webhook --- ### What data does it extract? | Field | Type | Description | |-------|------|-------------| | `modelId` | string | API slug (e.g. `llama-3.3-70b-versatile`) | | `modelName` | string | Display name (e.g. `Llama 3.3 70B`) | | `developer` | string | Model creator (Meta, OpenAI, Groq, etc.) | | `pricingType` | string | `token`, `hour`, `character`, or `free` | | `inputPricePerMillionTokens` | number | Input price in USD per 1M tokens | | `outputPricePerMillionTokens` | number | Output price in USD per 1M tokens | | `pricePerHour` | number | Audio model price in USD per hour | | `pricePerMillionChars` | number | TTS model price in USD per 1M characters | | `contextWindowTokens` | number | Maximum input context size in tokens | | `maxCompletionTokens` | number | Maximum output tokens per request | | `speedTokensPerSecond` | number | Inference speed in tokens/sec | | `rateLimitTPM` | number | Tokens per minute (developer plan) | | `rateLimitRPM` | number | Requests per minute (developer plan) | | `maxFileSizeMb` | number | Max file size for multimodal inputs | | `modelUrl` | string | Direct link to Groq's model documentation | | `scrapedAt` | string | ISO timestamp of when data was collected | --- ### How much does it cost to scrape Groq models? 🟢 **Very cheap.** Groq's models page lists roughly 15–30 models. At the current price of **$0.001 per model** extracted, a single full run costs approximately **$0.015–$0.03** plus the **$0.005 start fee**. | Run type | Models | Estimated cost | |----------|--------|----------------| | One-time full scrape | ~15 models | ~$0.02 | | Weekly monitoring (52 runs/year) | ~15 models | ~$1.00/year | | Daily monitoring (365 runs/year) | ~15 models | ~$7.00/year | All Apify platform compute costs are included. No proxy fees since the page is accessible without proxies. --- ### How to use Groq Models Scraper **Step 1:** Open the actor on [Apify Store](https://apify.com/automation-lab/groq-models-scraper). **Step 2:** Click **Try for free** — no configuration needed, the actor scrapes all models by default. **Step 3:** Click **Start** and wait 5–10 seconds. **Step 4:** View results in the **Dataset** tab. Export to JSON, CSV, or Excel. **Step 5 (optional):** Schedule recurring runs in the **Schedules** tab to monitor Groq pricing changes over time. --- ### Input parameters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `maxRequestRetries` | integer | `3` | Number of retry attempts if the Groq models page fails to load | The actor requires no mandatory input. Clicking **Start** with defaults scrapes all currently available Groq models. --- ### Output example ```json { "modelId": "llama-3.3-70b-versatile", "modelName": "Llama 3.3 70B", "developer": "Meta", "modelUrl": "https://console.groq.com/docs/model/llama-3.3-70b-versatile", "speedTokensPerSecond": 280, "pricingType": "token", "inputPricePerMillionTokens": 0.59, "outputPricePerMillionTokens": 0.79, "pricePerHour": null, "pricePerMillionChars": null, "rateLimitTPM": 300000, "rateLimitRPM": 1000, "contextWindowTokens": 131072, "maxCompletionTokens": 32768, "maxFileSizeMb": null, "scrapedAt": "2026-04-25T08:15:34.000Z" } ```` **Audio model example (Whisper):** ```json { "modelId": "whisper-large-v3", "modelName": "Whisper", "developer": "OpenAI", "modelUrl": "https://console.groq.com/docs/model/whisper-large-v3", "speedTokensPerSecond": null, "pricingType": "hour", "inputPricePerMillionTokens": null, "outputPricePerMillionTokens": null, "pricePerHour": 0.111, "pricePerMillionChars": null, "rateLimitTPM": 200000, "rateLimitRPM": 300, "contextWindowTokens": null, "maxCompletionTokens": null, "maxFileSizeMb": 100, "scrapedAt": "2026-04-25T08:15:34.000Z" } ``` *** ### Tips and best practices 💡 **Schedule for price monitoring** — Groq updates pricing and adds new models frequently. Schedule weekly runs and compare datasets to track changes automatically. 💡 **Combine with other model scrapers** — Pair this actor with [OpenRouter Models Scraper](https://apify.com/automation-lab/openrouter-models-scraper) or [Artificial Analysis Scraper](https://apify.com/automation-lab/artificial-analysis-scraper) to build a comprehensive cross-provider pricing comparison. 💡 **Use the `pricingType` field to filter** — Filter results by `pricingType: "token"` for LLM text models, `"hour"` for audio transcription models, and `"character"` for TTS models. 💡 **Check `rateLimitTPM` for production planning** — Before building on a Groq model, verify the TPM rate limit matches your expected traffic. Free and developer plans have different limits. 💡 **Track `speedTokensPerSecond`** — Groq's key differentiator is ultra-fast inference. Monitor this field to compare speeds as Groq adds new hardware acceleration. *** ### Integrations 🔄 **Zapier / Make.com** — Trigger downstream workflows when new models appear or prices change. Connect Groq model data to Slack notifications, Airtable, or Google Sheets automatically. 📊 **Google Sheets** — Export results directly to a Google Sheet for team-visible pricing dashboards. Use Apify's native Google Sheets integration or schedule the actor and auto-push results. 🤖 **AI cost calculators** — Feed model pricing data into your own cost estimation scripts. Use the structured `inputPricePerMillionTokens` and `outputPricePerMillionTokens` fields to power real-time cost previews in your app. 🗄️ **Data pipelines** — Push results to PostgreSQL, BigQuery, or Snowflake via Apify webhooks for long-term pricing trend analysis. 📬 **Webhook notifications** — Set up Apify webhooks to POST results to your endpoint whenever a run completes, enabling real-time pricing updates in your infrastructure. *** ### API usage #### Node.js (Apify client) ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const run = await client.actor('automation-lab/groq-models-scraper').call({}); const { items } = await client.dataset(run.defaultDatasetId).listItems(); console.log(`Extracted ${items.length} Groq models`); items.forEach(m => { console.log(`${m.modelId}: $${m.inputPricePerMillionTokens}/1M input tokens`); }); ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient("YOUR_APIFY_TOKEN") run = client.actor("automation-lab/groq-models-scraper").call(run_input={}) items = client.dataset(run["defaultDatasetId"]).list_items().items print(f"Extracted {len(items)} Groq models") for m in items: print(f"{m['modelId']}: ${m.get('inputPricePerMillionTokens')}/1M input tokens") ``` #### cURL ```bash ## Start the actor curl -X POST \ "https://api.apify.com/v2/acts/automation-lab~groq-models-scraper/runs?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{}' ## Get results (replace DATASET_ID with the run's defaultDatasetId) curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_APIFY_TOKEN" ``` *** ### Use with Claude AI (MCP) You can use Groq Models Scraper directly inside Claude via the [Apify MCP server](https://mcp.apify.com). #### Claude Code (terminal) ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/groq-models-scraper" ``` #### Claude Desktop / Cursor / VS Code Add to your MCP config: ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com?tools=automation-lab/groq-models-scraper", "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" } } } } ``` **Example prompts to use with Claude:** - *"Use the Groq Models Scraper to get all current Groq models and show me the cheapest option for long-context tasks."* - *"Scrape Groq's model list and tell me which models support more than 100K context window tokens."* - *"Run the Groq scraper and compare Llama 3 pricing on Groq vs what I'm paying on another provider."* *** ### Legality and terms of service This actor scrapes publicly accessible data from Groq's documentation page (`console.groq.com/docs/models`). The page is publicly accessible without authentication and contains no personal data. Scraping publicly available documentation for informational, research, and competitive intelligence purposes is generally accepted under fair use principles. Always review [Groq's Terms of Service](https://groq.com/terms-of-use/) before using the data commercially. The actor does not log in, bypass access controls, or scrape any user-specific or private data. *** ### FAQ **Q: How often should I run this actor to stay up to date?** A: Groq adds new models and updates pricing every few weeks. A weekly schedule is sufficient for most use cases. For tighter monitoring, run daily. **Q: Why are some fields null for certain models?** A: Not all fields apply to every model type. Whisper (audio) models don't have a context window or token pricing — they use per-hour pricing instead. TTS models (Orpheus) use per-character pricing. Null values indicate the field is not applicable for that model type. **Q: The actor returned fewer models than I expected. What happened?** A: Groq periodically removes deprecated models from their docs page. If you see fewer models than expected, the actor is showing the current live catalog. Check Groq's changelog for deprecated models. **Q: I'm getting an error or empty results. What should I do?** A: Groq occasionally updates their documentation page structure. If the actor returns 0 items or throws an error, please [open an issue](https://apify.com/automation-lab/groq-models-scraper) in the actor's review section. You can also try increasing `maxRequestRetries` to 5 to handle transient network issues. **Q: Can I get historical pricing data?** A: Yes — schedule recurring runs and each run's dataset captures a snapshot with the `scrapedAt` timestamp. Query across multiple dataset exports to build pricing trend analysis. *** ### Related scrapers - 🔗 [OpenRouter Models Scraper](https://apify.com/automation-lab/openrouter-models-scraper) — All AI models available on OpenRouter with pricing and capability metadata - 🔗 [Artificial Analysis Scraper](https://apify.com/automation-lab/artificial-analysis-scraper) — LLM benchmark data and pricing from Artificial Analysis - 🔗 [Replicate Scraper](https://apify.com/automation-lab/replicate-scraper) — Models and pricing from the Replicate platform - 🔗 [VastAI GPU Scraper](https://apify.com/automation-lab/vastai-gpu-scraper) — GPU rental pricing from Vast.ai for self-hosted inference cost comparisons # Actor input Schema ## `maxRequestRetries` (type: `integer`): Number of retry attempts if the Groq models page fails to load. ## Actor input object example ```json { "maxRequestRetries": 3 } ``` # Actor output Schema ## `overview` (type: `string`): No description # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "maxRequestRetries": 3 }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/groq-models-scraper").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "maxRequestRetries": 3 } # Run the Actor and wait for it to finish run = client.actor("automation-lab/groq-models-scraper").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "maxRequestRetries": 3 }' | apify call automation-lab/groq-models-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=automation-lab/groq-models-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Groq Models Scraper", "description": "📊 Scrape all Groq LLM models with pricing, context window sizes, speed benchmarks, rate limits, and model IDs from the official Groq docs page. No API key required.", "version": "0.1", "x-build-id": "Qte9FQkTO9AZqCGxl" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/automation-lab~groq-models-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-automation-lab-groq-models-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/automation-lab~groq-models-scraper/runs": { "post": { "operationId": "runs-sync-automation-lab-groq-models-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/automation-lab~groq-models-scraper/run-sync": { "post": { "operationId": "run-sync-automation-lab-groq-models-scraper", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "properties": { "maxRequestRetries": { "title": "Max request retries", "minimum": 1, "maximum": 10, "type": "integer", "description": "Number of retry attempts if the Groq models page fails to load.", "default": 3 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```