Groq Models Scraper

What does Groq Models Scraper do?

Groq Models Scraper extracts the complete catalog of AI models available on Groq — 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.

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

{
  "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):

{
  "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 or 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)

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

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

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

Claude Code (terminal)

$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:

{
  "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 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 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 — All AI models available on OpenRouter with pricing and capability metadata
• 🔗 Artificial Analysis Scraper — LLM benchmark data and pricing from Artificial Analysis
• 🔗 Replicate Scraper — Models and pricing from the Replicate platform
• 🔗 VastAI GPU Scraper — GPU rental pricing from Vast.ai for self-hosted inference cost comparisons