DEV Community: Viktor Kondas

Free hosting for vibe coding (2026)

Viktor Kondas — Mon, 05 Oct 2026 11:13:59 +0000

How to host your vibe-coded project for free — Cloudflare Pages, Vercel Hobby, Netlify, GitHub Pages, and Render, plus when Hobby is not enough (Stripe / commercial).

Free vibe coding stack — **Part 3* (hosting).*

Part 1 of Free vibe coding stack covered free cloud AI API keys. Part 2 was courses. Keys and training still leave you on localhost:3000. Part 3 is hosting — a live HTTPS URL for the frontend you just vibe-coded.

This chapter is Git frontend hosts. Databases and file storage are next in this series — Neon is the start-here Postgres, not a website host. Auth comes after that.

Start-here: Static HTML / CSS / JS or a marketing page → Cloudflare Pages (static requests are free and unlimited) or GitHub Pages (simplest). Next / React from Cursor → Vercel Hobby for DX — but Hobby is non-commercial personal use. Stripe, ads, donations, or paid client work means Pro.

Provider map

Provider	Best for	Free quota	Card?	Commercial	Custom domain
Cloudflare Pages	Static / edge	Unlimited static requests; 500 builds/mo	No	OK for static hobby + business sites*	Yes (100 / project on Free)
Vercel Hobby	Next / React DX	100 GB Fast Data Transfer / mo	No	Personal only	Yes (50 / project)
Netlify Free	Jamstack / forms	300 credits / mo (new accounts)	No	OK until credits run out	Yes
GitHub Pages	Docs / portfolios	1 GB site; soft 100 GB bandwidth	No	Not for store / SaaS	Yes
Render static	Git → CDN frontend	Hobby: 5 GB bandwidth, 500 build min	No*	Hobby is personal / prototype	Yes (2 included on Hobby)

Checked 17 Aug 2026 from official docs. Quotas move — re-check the dashboard before you promise a client a $0 bill. *Cloudflare Functions share the Workers Free 100k req/day cap. *Render bills extra bandwidth if you add a card and exceed the include; without a card, Free services can suspend.

Deploy from GitHub in Cursor

Same loop on every host below: push the repo, connect the GitHub app, pick the branch, wait for a *.pages.dev / *.vercel.app / *.netlify.app / *.github.io / *.onrender.com URL. Paste this into Cursor if you want the agent to walk you through one host:

Help me deploy this project to Cloudflare Pages or Vercel.
Walk me through: (1) putting the repo on GitHub if it is not there,
(2) connecting the host, (3) the correct build command and output folder,
(4) env vars for any API keys (never commit .env),
(5) the live URL. Do not add Stripe or ads on a free Hobby plan.

Cloudflare Pages

Cloudflare Pages is the generous static pick. Official docs: requests to static assets are free and unlimited on free and paid plans. You get 500 builds per month, one concurrent build, 100 projects, 100 custom domains per project, 20,000 files, 25 MiB max file.

The "unlimited" headline stops at Functions. Pages Functions share your Workers Free quota — 100,000 requests per day, resetting midnight UTC. A brochure site that never invokes Functions stays in the unlimited bucket. An API-on-the-edge app does not.

Create a free Cloudflare account at dash.cloudflare.com.
Workers & Pages → Create → Pages → Connect Git (GitHub or GitLab).
Set the build command and output directory your framework expects (or leave empty for a plain HTML folder).
Deploy. Add a custom domain in project settings when you have one.

Vercel Hobby

Vercel is still the lowest-friction path for Next.js and most React apps Cursor scaffolds. Hobby is $0. Fair-use (as of 29 Jul 2026) includes about 100 GB Fast Data Transfer per month, 1M edge requests, 1M function invocations, 200 projects, 50 domains per project. Exceed a cap and that feature typically pauses until the window resets — Hobby cannot buy extra usage.

The binding constraint is not bandwidth. It is the commercial-use rule: Hobby teams are non-commercial personal use only. Pro is $20/mo. See Hobby vs paid below.

Sign up at vercel.com with GitHub.
Add New → Project → import the repo. Accept the detected framework.
Add env vars in Project → Settings → Environment Variables (same names as local .env).
Every push to the production branch ships. Pull requests get preview URLs.

Netlify

Netlify still fits Jamstack sites that want forms and deploy previews. New accounts since 4 Sep 2025 are on credit-based Free: 300 credits per month, hard limit, no auto-recharge. When credits hit zero, projects pause and visitors see "Site not available" until the next cycle or you upgrade. Bandwidth is 20 credits per GB; each production deploy is 15 credits; deploy previews are 0 credits.

Older (legacy) Free accounts may still show a 100 GB-style bandwidth include. Do not assume that if you signed up this year — check Usage & billing.

Sign up at app.netlify.com with GitHub.
Add new site → Import from Git → pick the repo and build settings.
Watch the credit ledger if you deploy to production often (15 credits a pop adds up).

GitHub Pages

GitHub Pages is static only — no serverless, no SSR. Official limits: published site ≤ 1 GB, recommended source repo 1 GB, deploy timeout 10 minutes, soft 100 GB bandwidth / month, soft 10 builds/hour unless you use Actions. Custom domains work. It is not allowed as free hosting for e-commerce, commercial SaaS, or sites whose main job is taking payments.

Push a public repo (or use Actions from a private repo on a paid GitHub plan if you already have one).
Settings → Pages → deploy from main / /docs or a GitHub Actions workflow.
Wait for https://<user>.github.io/<repo>/.

Render (static)

Render static sites are free to deploy: Git-connected, CDN, TLS, PR previews. They count against the Hobby workspace include: 5 GB outbound bandwidth / month (then $0.15/GB if you have billing set up), 500 pipeline minutes, 2 custom domains included.

Do not mix this up with Free web services. Those are a different product: they spin down after 15 minutes idle, take about a minute to wake, and eat 750 Free instance hours / month. Fine for a toy API. Bad if you tell someone your "free static site" will cold-start.

Sign up at dashboard.render.com.
New → Static Site (not Web Service) → connect the repo → build command + publish directory.
Confirm the URL ends up on the CDN path, not a sleeping Node process.

Hobby vs paid — Stripe is the trigger

Free tiers are for hobby, demos, and learning. If you need a payment provider on the live URL, plan on a paid hosting tier.

Vercel Hobby vs Pro is the worked example. Fair use says Hobby is personal / non-commercial. Commercial includes:

Any method of requesting or processing payment from visitors (Stripe Checkout counts)
Advertising the sale of a product or service
Getting paid to create, update, or host the site
Affiliate linking as the primary purpose of the site
Ads (including AdSense)
Asking for donations

There is no "under $10 MRR is still Hobby" clause. One paying customer, or even a donate button, is the policy line. Pro is $20 / month per deploying seat, with a usage credit and the ability to pay for overages. Hobby cannot buy extra bandwidth.

Same idea, other hosts:

Cloudflare — static can stay $0; Functions / Workers traffic can blow the 100k/day Free cap. Paid Workers starts around $5/mo.
Netlify — Free cannot buy credits. Personal is $9/mo (1,000 credits + recharge). Pro starts at $20/mo.
GitHub Pages — policy, not a price list: no store / SaaS on Pages.
Render — static is cheap until bandwidth; always-on backends are Starter web services (~$7/mo), not Free.

Also: Replit and Hostinger

These are not in the free Git CDN map. They solve different jobs.

Replit is build-and-host in the browser. If you never left Replit, publishing there is simpler than exporting to GitHub → Vercel. It is still a platform plan with usage limits — not unlimited Cloudflare-style static. Use it when the project already lives there.

Hostinger is cheap traditional hosting: cPanel, WordPress, shared PHP. Useful if someone wants a classic site builder, not a Git push. It is paid, not a free frontend CDN. Do not pick it as the default for a Cursor Next.js app.

Practical tips

Env vars in the dashboard — never commit .env. Rotate keys if they hit GitHub.
Custom domain + HTTPS — all five Git hosts issue certificates; DNS is the slow part (A / CNAME at your registrar).
Preview deploys — share the PR URL, not localhost screenshots.
Quotas move — screenshot Usage the week you launch; Netlify credits and Vercel fair-use are the two that surprise people.
One host per project — do not dual-deploy "for backup" until you know which URL is canonical.

What's next in Free vibe coding stack

Hosting is the public URL. Coming parts in this series:

Database & storage — free Postgres / files (Neon start-here)
Auth — free user login stacks
Email & SMS — transactional mail without a credit card day-one
Monitoring — Search Console, analytics, and alerts
Payments — Checkout when Hobby is no longer enough

Browse tools we actually use on vibecoderslife.com/tools (Vercel, Hostinger, Replit, GitHub, Cursor — affiliate links marked where active).

FAQ

How do I host a vibe-coded project for free?

Push the repo to GitHub, connect Cloudflare Pages (static) or Vercel Hobby (Next/React), and use the *.pages.dev or *.vercel.app URL. Stay off Stripe, ads, and paid client work while you are on Hobby-class plans.

Is Vercel Hobby enough if I add Stripe?

No. Vercel's fair-use rules treat payment processing as commercial. Upgrade to Pro (or host somewhere whose terms allow it) before Checkout goes live.

Cloudflare Pages vs Vercel?

Cloudflare wins on unmetered static bandwidth. Vercel wins on Next.js DX and previews. If the site is HTML/CSS/JS, start on Pages. If Cursor just scaffolded Next, start on Vercel and read the Hobby rule before you sell anything.

Is Cloudflare Pages really unlimited?

Static asset requests are. Builds are 500/month. Functions share Workers Free at 100,000 requests/day. Do not promise "unlimited API" on the free plan.

Do I need a credit card?

Usually not for these five free Git hosts. Render may ask for a card if you exceed included bandwidth or pipeline minutes; without one, extra usage can suspend Free services instead of billing.

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Sources: Vercel Hobby / fair-use; Cloudflare Pages limits; Netlify credits; GitHub Pages limits; Render static. Numbers as of 17 Aug 2026 — verify in-product.

Disclosure: Replit and Hostinger links are referral links (same as on our Tools page). Vercel, Netlify, Cloudflare Pages, GitHub Pages, and Render are plain product URLs. Neon signup uses our existing referral (database and storage comes next). No paid placement by the hosting providers. Drafting/editing used AI assistance; the hosting map is from my own shipping work.

Free vibe coding courses (2026)

Viktor Kondas — Fri, 02 Oct 2026 11:00:00 +0000

A practical map of free and low-cost AI coding training — Codecademy, Udemy picks, Anthropic Skilljar, OpenAI Academy, Cursor Workshops, Grow with Google, plus a clear start-here path.

Free vibe coding stack — **Part 2* (courses).*

Part 1 of Free vibe coding stack covered free cloud AI API keys. Keys get you unblocked. Training gets you productive. Part 2 is courses — free vendor workshops first, then structured paths, then paid depth when a sale actually helps.

Start-here (verdict first): Day 0 → Cursor Workshops. Week 1 → Anthropic Skilljar or OpenAI Academy. Then one structured path (Codecademy). Buy Udemy only on a sale for longer video curricula. Grow with Google if you want broader digital / AI literacy — not day-one agent shipping.

Start-here path

Day 0 — Cursor Workshops. Learn the IDE/agent you already build in. Pick Cursor 101, Rules / Skills / MCP, or whatever's live this week.
Week 1 — vendor-native skills. Anthropic Skilljar (Claude Code, MCP, agent skills) or OpenAI Academy — match the model stack you actually use.
Then — structured path. Codecademy Pro paths / agent courses, or the live Building Agentic AI Applications for Beginners bootcamp when a cohort is open (code EARLY20 for 20% off — time-limited; verify at checkout).
Depth / paid sales — Udemy. Prefer instructors Ed Donner and Maximilian Schwarzmüller over random "AI agent masterclass" spam.
Career / fundamentals — Grow with Google (Europe). Broader literacy tracks, not a substitute for Cursor + one vendor academy.

Codecademy

Summary: Interactive lessons, career paths, and occasional live bootcamps. Good when you want a syllabus and quizzes instead of YouTube chaos.

How to register: Create an account via the Codecademy referral link (disclosed). Free catalog exists; Pro unlocks most guided paths. Bootcamps are separate paid cohorts.

Best picks for vibe / agents:

Building Agentic AI Applications for Beginners — 12-week live bootcamp (Python → LLMs / RAG / orchestration). Landing pages have advertised EARLY20 for 20% off; cohort calendars change — if overview says "no upcoming," wait for the next start date.
Self-paced: Learn How to Build AI Agents and the Build AI Agents with OpenAI and LangChain path when you want structured practice without live sessions.

Free vs paid: Free intro lessons; Pro / bootcamp are paid. Don't assume the whole agent track is forever free.

Who it fits: Beginners who want accountability and a curriculum; people who already like Codecademy's UI.

Try Codecademy →

Udemy

Summary: Huge marketplace. Quality varies wildly — filter by instructor, recent updates, and project load, not star spam.

How to register: Browse via the Udemy referral link. Wait for sitewide sales if you can; list prices are theatre.

Instructors / courses verified at write time:

Ed Donner — AI Engineer Core Track: LLM Engineering, RAG, QLoRA, Agents and AI Engineer Agentic Track: The Complete Agent & MCP Course (CrewAI, LangGraph, MCP, multi-framework builds).
Maximilian Schwarzmüller — AI Agents & Workflows: The Practical Guide (clearer conceptual entry if Donner's agentic track feels heavy).

Free vs paid: Paid video (often heavily discounted). Not a free academy.

Who it fits: Self-paced learners who want 10–40 hours of depth after free vendor workshops.

Browse Udemy →

Anthropic Skilljar

Summary: Anthropic's official course hub on Skilljar — Claude for work, Claude Code, Claude API, MCP, AI Fluency, agent skills / subagents.

How to register: Sign up at anthropic.skilljar.com (Skilljar account; Anthropic Console account is separate if you later use the API).

Best courses for vibe coders: Claude Code 101 / Claude Code in Action, Introduction to Model Context Protocol, Introduction to agent skills, Building with the Claude API.

Free vs paid: Learning content is free to access via Skilljar; certificates / progress tracking follow Skilljar's flow.

Who it fits: Anyone shipping with Claude / Claude Code / MCP day to day.

Open Anthropic Skilljar →

OpenAI Academy

Summary: OpenAI's free learning hub for builders and teams using ChatGPT / the OpenAI API / agent patterns.

How to register: Start at academy.openai.com and pick tracks that match your stack (API, assistants / agents, product use).

Free vs paid: Academy content is free; API usage is separate (see Part 1 for free-key options if you're experimenting).

Who it fits: Codex / ChatGPT / OpenAI API users who want vendor-native guidance before buying a third-party bootcamp.

Open OpenAI Academy →

Cursor Workshops

Summary: Free live and recorded sessions from the Cursor team — 101/201, Rules / Skills / MCP, model selection, cloud agents, role-based sessions.

How to register: Browse upcoming events at cursor.com/workshops and join what matches your role.

Best first picks: Cursor 101, Cursor Rules / Skills / MCPs, Model Selection & Token Efficiency.

Free vs paid: Workshops are free; Cursor product plans are separate.

Who it fits: Anyone whose daily driver is Cursor — start here before paying for agent theory elsewhere.

View Cursor Workshops →

Grow with Google (Europe)

Summary: Google's Europe-facing digital skills / AI literacy programs — career and fundamentals oriented more than "ship an agent tonight."

How to register: Start at grow.google/intl/europe/ and pick country / program availability.

Free vs paid: Core Grow tracks are free; partner certificates may vary by country.

Who it fits: Career switchers and teams needing broad AI literacy — not a replacement for Cursor + Skilljar / Academy.

Explore Grow with Google →

Also useful (curated extras)

DeepLearning.AI short courses — prompt engineering / agentic AI videos are free to audit; graded work and certificates often need Pro. Start at deeplearning.ai/courses.
Hugging Face AI Agents Course — free end-to-end agents path; free cert if you complete the stated assignments. huggingface.co/learn/agents-course.
Microsoft Learn / GitHub Skills + AI Agents for Beginners — free Copilot / agent lesson tracks. AI Agents for Beginners.
freeCodeCamp — AI-assisted coding / ML YouTube + curriculum, free with no course upsell. freecodecamp.org.

Comparison

Platform	Free?	Certificate?	Best for	Time to first project
Cursor Workshops	Yes	No (session)	Tool fluency	Same day
Anthropic Skilljar	Yes	Via Skilljar	Claude / MCP / Code	1–3 days
OpenAI Academy	Yes	Varies by track	OpenAI / Codex stack	1–3 days
Codecademy	Partial	Pro / bootcamp	Structured beginners	~1 week
Udemy	No (sales)	Course cert	Deep video curricula	1–2 weeks
Grow with Google	Yes*	Often	Career / literacy	Weeks
Hugging Face Agents	Yes	Free if completed	Open-source agents	~1 week

Checked Aug 2026. Offers and cohorts change — re-verify EARLY20, bootcamp dates, and Academy tracks before you pay.

Summary

Start free where you already work: Cursor Workshops, then Anthropic Skilljar or OpenAI Academy. Add one structured path (Codecademy) if you need a syllabus. Buy Udemy on a sale for Donner / Schwarzmüller depth — don't stack three bootcamps. Part 1's free API keys still matter: training without a key burns paid credits for no reason.

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Disclosure: Codecademy and Udemy links are referral links (same as on our Tools page). Cursor Workshops, Anthropic Skilljar, OpenAI Academy, and Grow with Google are plain product URLs. No paid placement by the course providers for this article. Drafting/editing used AI assistance; the course map is from my own shipping work.

Free AI API keys for vibe coding (2026)

Viktor Kondas — Wed, 30 Sep 2026 11:00:00 +0000

Google AI Studio, Groq, Mistral, Qwen, DeepSeek, Cerebras, GitHub Models, OpenRouter & more — create keys step by step and plug them into Cursor or VS Code Cline.

Free vibe coding stack — **Part 1* (API keys).*

I get this question constantly in vibe-coding chats and social groups: "Where do I get free API keys so I can keep building without burning Cursor / Claude / GPT credits?" So I'm starting a series — Free vibe coding stack — collecting the free (or freemium) cloud pieces you actually need. Part 1 is API keys. Later parts cover free hosting, backends, databases, auth, email, and monitoring.

Quick answer: Yes — you can build with free cloud LLM APIs in 2026 without installing models on your laptop. Start with Google AI Studio (Gemini) + Groq + OpenRouter (:free models). Paste keys into Cursor BYOK or VS Code + Cline, then keep shipping. Rate limits and free-tier policies change — always confirm live quotas in each console.

This guide is cloud API only. No Ollama, no LM Studio, no "download 40GB of weights." If it needs a local GPU, it's out of scope for Part 1.

Provider map

Provider	Best for	Card?	Cursor path
Google AI Studio	Default Gemini free tier	No	Native Gemini key
Groq	Fast open models	No	OpenAI-compatible URL
Cerebras	High-speed inference	No	OpenAI-compatible URL
Mistral (Studio)	EU / Codestral / open models	No (Free mode)	Cline / compatible
OpenRouter	One key, many `:free` models	No*	OpenAI-compatible URL
GitHub Models	Free with GitHub account	No	Cline / Azure-style
Qwen (Model Studio)	Qwen family APIs	Varies by region	Cline / compatible
DeepSeek	Cheap API (not forever-free)	Usually yes after promo	OpenAI-compatible URL
Cloudflare Workers AI	Edge / Workers workflows	No for free tier	Cline / Workers
NVIDIA (build.nvidia.com)	NIM / NGC catalog trials	Account; check offer	Cline / compatible
Hugging Face	Inference tokens / free endpoints	No for token	Cline / HF provider
Cohere	Trial / eval keys	Trial limits	Cline
SambaNova Cloud	Big open models, free eval tier	No for Free tier	OpenAI-compatible URL

*OpenRouter free routes work without a card; a one-time credit top-up raises free-model daily caps. Live limits live in each provider dashboard — don't treat blog tables as SLAs.

1. Google AI Studio (Gemini) — create an API key

Still the best all-rounder free tier for most vibe coders: Gemini Flash / Pro text models, no billing account required to start. Free-tier prompts may be used to improve Google products — keep secrets and client data out.

Open aistudio.google.com and sign in with Google.
Open the API keys / Get API key flow (sidebar or project settings).
Create or select a Google Cloud project when prompted — the key is tied to that project's quota.
Click Create API key, copy it once, store it in a password manager or .env (never commit it).
Check rate limits for that project inside AI Studio — Google no longer publishes a single public free-tier table; your project view is the source of truth.

Docs: Gemini API keys.

2. Groq — free fast inference key

Groq is the "I need tokens now" provider: Llama and friends at interactive speed, OpenAI-compatible API, no card for the free tier.

Go to console.groq.com and create an account.
Open API Keys.
Create a key, name it (e.g. cursor-dev), copy immediately.
Base URL for OpenAI-compatible clients: https://api.groq.com/openai/v1.
Watch RPM / RPD in the console — free caps are generous per day but tight per minute.

3. Cerebras Cloud — free speed alternative

Another OpenAI-compatible speed lane. Free tier is self-serve: email signup, no waitlist, no card for free quotas (confirm live token/day caps in console).

Sign up at cloud.cerebras.ai and verify email.
Open API Keys in the left nav.
Generate a key (csk-…), copy once.
Base URL: https://api.cerebras.ai/v1 — see Cerebras quickstart.

4. Mistral Studio — free mode API key

Mistral's developer console (Studio / La Plateforme) enables Free mode with usage and rate limits — no credit card required for free mode. Useful for Codestral and Mistral open models.

Create an account at console.mistral.ai.
Confirm you're on Free mode / Experiment (billing may still need a plan selection even when free — check console).
Sidebar → API Keys → Create new key.
Set a name + optional expiration; copy the secret once.
Test against https://api.mistral.ai/v1 — docs: Activate Studio and generate an API key.

5. OpenRouter — one key, many free models

OpenRouter aggregates providers. Models tagged :free are the free routes. Account-wide free caps are modest (e.g. low requests/day) unless you add a small credit balance — still the easiest way to try DeepSeek / Qwen / Llama free variants without juggling five consoles.

Sign up at openrouter.ai.
Open Keys → create a key → copy.
Filter the model catalog for Free / :free suffixes.
Base URL: https://openrouter.ai/api/v1 (OpenAI-compatible).
Optional: one-time credit top-up raises free-route daily limits — read the current free-model docs in-dashboard.

6. GitHub Models — free with your GitHub account

GitHub Models gives rate-limited access to a catalog of models for prototyping. Ideal if you already live in GitHub.

Sign in at GitHub Marketplace → Models (or Models playground from docs).
Accept terms / enable Models access for your account or org.
Create a fine-grained PAT or use the Models key flow documented in GitHub's Models docs (scopes change — follow the current "Get started with GitHub Models" guide).
Copy the token; store it like any API key.
Use their documented endpoint / Azure AI Inference-compatible clients — rate limits are free-tier and reset on a published schedule.

7. Qwen — Alibaba Cloud Model Studio / DashScope

Qwen APIs run through Alibaba Cloud's Model Studio / DashScope. Free or trial quotas depend on region and promotions — create an account in the console that matches your region.

Open Alibaba Cloud Model Studio (or DashScope console for your region).
Complete account / real-name steps if required for your region.
Create an API key under API-KEY management.
Copy the key; note the correct regional base URL from official docs.
Check free quota / billing alerts before agent loops.

8. DeepSeek — cheap API (honest free status)

Important: DeepSeek's chat app is free; the API is pay-as-you-go. New accounts sometimes get a small granted balance — not a permanent free tier. Still worth a key because pricing is usually very low, and OpenRouter often exposes DeepSeek-class models on :free routes for zero-cost experiments.

Register at platform.deepseek.com (separate from chat.deepseek.com).
Open API Keys → create key → copy sk-… once.
Check Billing for any granted balance; top up if you need sustained use.
Base URL: https://api.deepseek.com (OpenAI-compatible).

9. More free / freemium cloud keys worth having

Cloudflare Workers AI

Create a free Cloudflare account at dash.cloudflare.com.
Enable Workers / Workers AI; create an API token with Workers AI permissions.
Use the Workers AI REST API or bindings — free daily neurons apply; check the current free allocation in docs.

NVIDIA build.nvidia.com / NIM

Sign in at build.nvidia.com with an NVIDIA account.
Pick a model → get API key / generate code snippet from the catalog.
Trial / free credits vary — treat as evaluation keys, not unlimited production.

Hugging Face

Create an account at huggingface.co.
Settings → Access Tokens → create a token with inference permissions you need.
Call Inference Providers / Inference API endpoints that still offer free or credit-based access — catalog and pricing move often.

Cohere Trial

Sign up at dashboard.cohere.com.
Create an API key under API Keys.
Trial / evaluation limits apply — fine for prototyping, not high-RPM agents.

SambaNova Cloud

Sign up at cloud.sambanova.ai — Free tier without a payment method.
Create an API key in the console.
Base URL: https://api.sambanova.ai/v1 (OpenAI-compatible). Free tier is evaluation-scale (tight RPD) — see SambaNova rate limits.

Where to use the keys: Cursor BYOK & VS Code Cline

Keys are useless until your editor can call them. Two practical paths for vibe coding:

Cursor — Bring Your Own Key

Install / open Cursor (homepage — same as our Tools page).
Go to Settings → Models.
Native fields: paste Google Gemini (and OpenAI / Anthropic if you have paid keys) into the matching API key slots and verify.
OpenAI-compatible providers (Groq, Cerebras, OpenRouter, DeepSeek, SambaNova): use the OpenAI API key field + Override OpenAI Base URL with that provider's /v1 endpoint, then enable the model IDs you need.
Start or continue your project — Chat / Agent routes that honor BYOK will bill the provider (or free tier), not only Cursor's included pool. Tab completion and some Cursor features may still use Cursor's own models.

Cursor's officially documented BYOK providers are narrower than "every OpenAI-compatible host." OpenRouter and some custom endpoints work for many people via base URL override, but model names and tool-calling can break. If a model fails verify, fall back to Cline in VS Code for that provider — don't fight the editor for hours.

Get Cursor →

VS Code + Cline

Install VS Code (free).
Install the Cline extension from the marketplace.
Open Cline settings → choose provider (OpenRouter, OpenAI-compatible, Gemini, etc.).
Paste the matching API key + base URL / model ID.
Point Cline at your project folder and keep building — same keys, more flexible provider matrix than Cursor's native list.

Practical tips

One key per tool — Cursor key, Cline key, CI key. Easier to revoke when something leaks.
Never commit keys — use .env + .gitignore; rotate if a key hits GitHub.
Failover — when Groq 429s, hop to Cerebras or Gemini; when Gemini throttles, open OpenRouter :free.
Free-tier data use — Google free tier may train/improve products; don't paste production secrets.
Quotas move — screenshot your dashboard limits the day you set up; revisit monthly.

What's next in Free vibe coding stack

API keys are the fuel. Coming parts in this series:

Free hosting — static + serverless options
Backend & database — free Postgres / KV / edge
Auth — free user login stacks
Email & monitoring — transactional mail + alerts without a credit card day-one

Browse tools we actually use on vibecoderslife.com/tools (Cursor, Neon, Replit, v0, and more — affiliate links marked where active).

FAQ

Do I need a credit card for free AI API keys?

Often no — Google AI Studio, Groq, Cerebras, Mistral Free mode, SambaNova Free tier, GitHub Models, and Cloudflare's free Workers AI allotment typically start without a card. OpenRouter works without a card for :free models; credits are optional. DeepSeek API expects a balance after any promo credit.

Which free key should I add to Cursor first?

Gemini (native) for everyday coding help, then Groq or OpenRouter via OpenAI-compatible base URL for speed / model shopping.

Is local Ollama "free API"?

It's free compute on your machine — out of scope here. This series part is cloud keys only.

Can I use these keys in production?

Free tiers are for learning, demos, and light side projects. Production traffic needs paid tiers, ZDR options, and proper secrets management.

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Sources: Google AI Studio / Gemini API key docs; Groq Console; Cerebras Cloud; Mistral Studio; OpenRouter; GitHub Models; DeepSeek Platform; SambaNova Cloud. Free-tier numbers change — verify in-product.

Disclosure: Cursor links go to cursor.com (their referral program ended). Other Tools affiliates (e.g. Neon, Replit) may appear in later series parts. No paid placement by the API providers listed. Drafting/editing used AI assistance; the provider walkthroughs are from my own shipping work.

Cursor Origin: Git hosting for the agent era (early beta guide)

Viktor Kondas — Mon, 28 Sep 2026 10:06:28 +0000

We teased Origin in the free-hosting newsletter. Here's the junior-friendly setup: claim a codebase, install the CLI, sync from GitHub, keep GitHub as source of truth — Origin as backup while the beta evolves.

Back in the free hosting for vibe coding (2026) newsletter — Part 3 of Free vibe coding stack — we said we were testing Cursor Origin and that a write-up with what actually works (and what doesn't) would land here.

Here it is.

This is the early-beta guide I wish I'd had on day one: what Origin is, who can use it, how I set it up (GitHub stays primary), and a junior-friendly walkthrough from Cursor's docs. No invented demo numbers — just the paths that are documented today.

Start-here: claim a codebase at cursor.com/codebase → curl -fsSL https://downloads.cursor.com/origin/install.sh | sh → origin auth login → Sync from GitHub. Keep GitHub as source of truth. Docs: cursor.com/docs/origin.

What is Cursor Origin?

Origin is Cursor's own git forge — a place to store, share, browse, and review code, the same basic job GitHub / GitLab / Bitbucket do.

Cursor's framing: a git forge for the agent era. Agents already write a lot of the diffs; Origin is meant to sit next to Cursor's agents, automations, and PR review instead of living only on a separate host.

In early beta you can:

Create Origin repositories (including from Cursor agents)
Clone, push, and pull with standard git
Mirror a GitHub repository into Origin
Open, review, and merge pull requests
Browse and search code at cursor.com/codebase
Connect automations and cloud agents to Origin repos
Install the Origin CLI for terminal workflows

Primary docs: cursor.com/docs/origin. Changelog kickoff: Origin Code Hosting (17 Aug 2026).

Short aside: Graphite

Cursor acquired Graphite (deal announced 19 Dec 2025). The Graphite team builds Origin. Graphite's stacked-PR DNA is useful context — not a promise that every unshipped review feature is live. Cursor's own changelog says essentials first (repos, PRs, browse, GitHub sync) and agent-native features ship soon. I'll stick to that wording.

Who it's for (plans)

Origin code storage is on Pro, Teams, and Enterprise. It is not on Free plans.

Access opens in stages, so you may not see Origin immediately after it becomes available for your plan. Enterprise admins can opt out. Teams on legacy privacy mode need to switch to Privacy Mode first.

If you don't see a Codebase / Origin entry yet: you're not doing it wrong — the rollout is staged.

My setup: GitHub primary, Origin as backup

I've synced a few of my repos to Origin.

Stance (locked):

GitHub stays my primary remote — source of truth for day-to-day work, CI, Issues, and the ecosystem I already use.
Origin is backup / mirror while the feature evolves — browse, search, agent workflows, and a second copy if GitHub is having a bad day.
I'm excited about what Origin brings next. I'm not ripping GitHub out.

That matches how synced repos work in the docs: GitHub = source of truth, Origin = mirror. Pushes to the Origin HTTPS remote go to GitHub; Origin updates after GitHub accepts the push. PRs sync both ways.

The landscape: GitHub, GitLab, Bitbucket, Origin

Most vibe-coded projects already live on one of three hosts:

Host	Typical role
GitHub	Default for Cursor / Vercel / Actions ecosystems
GitLab	Self-managed / DevOps-heavy teams
Bitbucket	Atlassian-heavy shops
Origin	New Cursor-native forge (early beta)

Together, GitHub + GitLab + Bitbucket (and now Origin as the new option) cover roughly 99% of the codebases you'll touch. You don't need to "pick a religion." You need a primary remote you trust, plus optional mirrors for backup and agent workflows.

Enable Origin (claim a codebase)

Before anyone on the team can use Origin, someone claims a codebase name — the namespace your repos live under ({owner} in https://cursor.com/codebase/{owner}/{repo}).

During the beta you can't change that namespace after it's claimed. Choose carefully.

Open cursor.com/codebase
Select Get Started and follow the setup flow
Admins can disable Origin later from the dashboard if needed

After enablement, the codebase home lists repos. Icons show whether a repo is Origin-hosted or synced from GitHub.

Install the Origin CLI + auth

The Origin CLI (origin) is separate from the Cursor Agent CLI (agent).

macOS, Linux, and Windows (WSL):

curl -fsSL https://downloads.cursor.com/origin/install.sh | sh

The installer puts the binary at ~/.local/bin/origin. If your shell says command not found: origin, add that directory to your PATH.

zsh:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

bash:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

Verify and sign in:

origin --version
origin auth login

Complete the browser flow with the Cursor account that has Origin access. Signing in also sets up the git credential helper, so git push / git pull against Origin remotes work without extra token juggling.

Useful CLI bits:

origin repo create my-project
origin update

origin repo create without a slash creates the repo in your account's namespace. Agents can drive the same commands.

Docs: Install the Origin CLI.

Sync from GitHub (recommended for existing work)

If the code already lives on GitHub, don't recreate it empty — mirror it.

Prerequisites

Cursor account with Origin access (Pro / Teams / Enterprise)
Cursor GitHub app connected to the org or account that owns the repo
GitHub admin on the repository you want to sync

Steps

Open cursor.com/codebase
Select Sync from GitHub
Choose the GitHub organization and repository
Confirm the sync

When it finishes, open the Origin copy to browse files and history. Sync status lives under Settings → General. Synced repos show Origin as the mirror and GitHub as the source.

What syncs vs what doesn't

Included	Not included
Git history, branches, and tags	GitHub Issues
Code you can browse and search on Origin	GitHub Actions workflows and secrets
GitHub pull requests you can review in Cursor	Branch protections (as GitHub settings)
Ongoing updates so Origin stays current

Workflow files may still be in the git tree. They do not run on Origin as GitHub Actions. Issues and CI configuration stay on GitHub.

Docs: Mirror a GitHub repository.

Create an Origin-native repo (alternative)

Use this when the project does not already live on GitHub, or you explicitly want Origin as source of truth.

From cursor.com/codebase:

Select New
Enter a Repo Name and choose Internal or Private
Select Create Repo
Copy the clone URL from the green Code button

Push your first commit:

git clone https://origin.cursor.com/{owner}/{repo}.git
cd {repo}
# add your files
git add .
git commit -m "Initial commit"
git push -u origin main

Or attach a remote to an existing local project:

cd your-project
git remote add origin https://origin.cursor.com/{owner}/{repo}.git
git push -u origin main

You can also ask a Cursor agent to create an Origin repo as part of a task — it can install the CLI, sign in, create, set the remote, and push (same permissions as your account).

Docs: Create an Origin repository.

Push, pull, clone, PRs, browse

Clone URL form (HTTPS):

https://origin.cursor.com/{owner}/{repo}.git

Example:

git clone https://origin.cursor.com/acme/checkout.git

On a mirrored GitHub repo, that same URL is the remote you use — but GitHub stays source of truth. git push to this remote goes to GitHub; Origin mirrors after.

Browse and search: cursor.com/codebase.

Pull requests: every repo has PRs. On synced repos, PRs sync both ways — comment in Cursor and it posts to GitHub; replies on GitHub show up in Cursor.

Optional: dual-push remote (advanced)

While you evaluate, you can keep GitHub and Origin in parallel with push URLs:

git remote set-url --add --push origin https://github.com/acme/checkout.git
git remote set-url --add --push origin https://origin.cursor.com/acme/checkout.git

For a full history copy from GitHub into Origin, prefer the Sync from GitHub UI over hand-rolled remotes.

Docs: Clone, Push & Pull.

When GitHub is unavailable (backup angle)

On a mirrored repo, docs describe keeping work on the Origin copy with origin/* branches and origin push local:

git branch origin/my-state HEAD
origin push local

That path writes Origin-only refs under origin/…. It is not a substitute for git push origin when you want a normal GitHub PR. Reads of an already-synced repo may still work over the HTTPS clone URL; Git LFS batch does not fail over. Use this carefully as a backup / keep-coding path, not as your default daily workflow.

What does NOT sync (honest beta)

Worth repeating so nobody gets surprised mid-migration:

Issues stay on GitHub
Actions workflows and secrets stay on GitHub (files in the repo ≠ runners on Origin)
Branch protections as GitHub settings don't come over as a full Settings clone
Branches named origin or origin/… on GitHub are skipped on purpose (so they can't overwrite Origin-only workspace branches)

Apps already called out in the Origin Code Hosting changelog: Vercel, Depot, and Buildkite, with more coming. Third-party explainers note Depot/Buildkite as Origin-hosted-oriented — always re-check Cursor's Integrations docs for the current matrix.

Detach anytime: Settings → General → Detach from GitHub (Danger Zone). That stops sync and makes the Origin copy standalone; your GitHub repo is not deleted.

Cloud agents + Origin (light)

Origin works with Cursor Automations and cloud agents:

Point an automation at an Origin repo the same way you would at connected GitHub / GitLab
Cloud agents can clone, branch, commit, and push
On an Origin-hosted repo they open Origin PRs
On a mirrored GitHub repo they open GitHub PRs

Local agents can create Origin repos via the CLI. Docs: Origin integrations.

What I'd do

If you're on Pro / Teams / Enterprise and Origin is visible, try it on a non-critical repo first.
Prefer Sync from GitHub for existing work — keep GitHub as source of truth.
Send feedback to hi@cursor.com (Cursor asks for any and all feedback in the docs).
Keep your primary forge (GitHub / GitLab / Bitbucket) until Origin's beta gaps (Issues, Actions, protections, ecosystem) match how you actually ship.

I'll keep watching what ships next — especially agent-native review — and update when the product moves. For now: mirror, don't migrate your whole life.

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Sources: Origin overview · CLI · Clone / push / pull · Mirror GitHub · Create repository · Origin Code Hosting changelog.

Disclosure: No affiliate links for Cursor Origin in this post. Links go to Cursor docs, changelog, and codebase UI. Numbers and flows checked against Cursor docs at write time (21 Sep 2026); staged rollout means your UI may differ slightly. Drafting/editing used AI assistance; the setup stance and walkthrough are from my own shipping work.

How I moved away from Replit and cut my stack to ~$20/month

Viktor Kondas — Wed, 23 Sep 2026 09:26:03 +0000

Neon, Vercel, Clerk, and Cursor replaced Replit DB, hosting, and auth — without losing Stripe or Apify.

I didn't leave Replit because it's a bad product. I left because the bill stopped making sense.

Replit Agent is brilliant when you want everything in one browser tab: code, database, auth, deploy, AI help. For a vibe coder shipping a side project, that convenience is real. But once I was iterating daily — asking questions, running agents, fixing one thing and breaking another — every task felt like it had a meter attached. Usage stacked up fast. What started as "I'll pay for speed" turned into hundreds of dollars a month for a project that wasn't even at revenue yet.

So I migrated. Same app idea, same Stripe and Apify integrations, same domain — different foundation. Today my predictable software cost is basically $20/month for Cursor. Everything else sits on generous free tiers until I actually scale.

This site — Vibe Coder's Life — runs on the same stack: static pages on Vercel, subscribers and posts in Neon. I practice what I preach.

This is the path I took, step by step, for anyone who's vibe coding hard but doesn't want Replit to eat their budget.

What I was paying for on Replit (and why it hurt)

Replit bundles a lot:

In-browser IDE + Agent — talk to AI, edit files, run the app
Hosted Postgres — database without leaving the platform
Auth — login/signup without wiring a third party
Deploy — your app live on a Replit or custom URL

That's exactly why it's popular. You never context-switch.

The pain point for me wasn't the subscription line item alone. It was Agent usage: follow-up questions, refactors, "try again," debugging loops. Each session added up. I wasn't on an enterprise budget — I was building in public, learning, and experimenting. Paying Replit-scale money to ask "why is my waitlist form broken again" felt wrong.

I wanted:

Predictable monthly cost
The same AI-assisted workflow (sidebar agent, not a scary blank terminal)
Production-grade pieces I could reuse on future projects
Skills that transfer — Git, env vars, deploy pipelines

That pointed away from an all-in-one browser bill and toward best-in-class free tiers + one paid IDE.

The replacement stack (confirmed)

What Replit gave you	What I use now	Typical cost
Replit DB (Postgres)	Neon serverless Postgres	Free tier
Replit Auth	Clerk	Free up to ~10k MAU
Replit hosting	Vercel	Free tier
Replit Agent / IDE	Cursor	$20/mo Pro
Apify	Same — API key in env	Pay per use (unchanged)
Stripe	Same — API keys in env	Free until you process payments
Source control	GitHub private repo	Free

Stripe and Apify didn't need a platform swap. I copied the same keys into .env locally and into Vercel's environment variables. The integration code barely cared where it ran.

The real work was database, auth, and deployment — the parts Replit had been hiding behind "it just works."

Before you touch anything: export your secrets

Do this while Replit still works.

Open your Replit project → Secrets (or Tools → Secrets).
Write down every key and value:
- Stripe publishable + secret keys
- Apify API key
- Database URLs
- Auth secrets
- Anything custom (webhook secrets, etc.)
Store them in a private note — not in chat, not in a screenshot on social.

Then verify GitHub has your full codebase:

Main app entry (e.g. index.js, main.py, app/)
package.json or requirements.txt
Frontend assets
Config files

If something's missing, commit and push from Replit before you migrate. Your GitHub repo becomes the source of truth.

Phase 1: Get the project on your machine with Cursor

You don't need to love the terminal on day one. Cursor feels close to Replit: files on the left, editor in the middle, Agent in the sidebar (like Replit Agent).

Install (all free except Cursor):

Cursor — download and install like any desktop app
Node.js LTS — if your stack is JavaScript
GitHub — free account for your repos

Clone your repo:

Open Cursor.
Cmd+Shift+P (Mac) or Ctrl+Shift+P (Windows) → Git: Clone.
Paste your private GitHub repo URL.
Pick a folder (Documents, Desktop, whatever).
Open the cloned folder when prompted.

You now have the same code Replit had — locally.

Create .env:

Right-click the project root → New File → .env

APIFY_API_KEY=your_key_here
STRIPE_SECRET_KEY=your_key_here
STRIPE_PUBLISHABLE_KEY=your_key_here
# add everything else from Replit Secrets

Open .gitignore and confirm .env is listed. Never push secrets to GitHub.

Phase 2: Replace Replit DB with Neon Postgres

Sign up at neon.tech (GitHub login is fine).
New project → pick a region close to your users.
Copy the pooled connection string — looks like: postgresql://user:pass@ep-xxx.region.aws.neon.tech/neondb?sslmode=require
Add to .env:

DATABASE_URL=postgresql://...

Use Cursor Agent for the code changes. Open Agent (Cmd+L / sidebar) and paste something like:

I'm migrating off Replit. Replace Replit's database with Neon Postgres. DATABASE_URL is in .env. Find all DB usage, switch to standard Postgres (pg or your ORM), add a migration/schema file to recreate tables, and load env with dotenv. Walk me through each file you change.

Agent will propose diffs. Review them — you're learning what a database connection actually looks like, which pays off on every future project.

Run migrations against Neon (SQL file or ORM migrate command — Agent will tell you which).

Phase 3: Replace Replit Auth with Clerk

Sign up at clerk.com.
Add application → name it after your product.
Enable Google (or whatever you used on Replit).
Copy Publishable and Secret keys into .env:

NEXT_PUBLIC_CLERK_PUBLISHABLE_KEY=pk_...
CLERK_SECRET_KEY=sk_...

Agent prompt:

Remove Replit Auth. Install Clerk, wrap the app with ClerkProvider, replace login/logout/session code with Clerk, keep protected routes protected. Show me every file you touch.

Test locally: sign up, sign in, hit a protected page, sign out.

Phase 4: Deploy on Vercel

Push your migrated code to GitHub (Cursor's Source Control panel works if terminal feels heavy: stage → commit → push).
vercel.com → sign in with GitHub → Import your repo.
Before Deploy: Environment Variables → add every key from .env (same names, same values).
Deploy.

You get a URL like your-app.vercel.app. Test auth, DB writes, Stripe test mode, Apify calls.

Ongoing deploys: push to main → Vercel rebuilds. No manual "publish" button like Replit.

Phase 5: Point your domain (then verify)

In Vercel → Project → Settings → Domains → add apex and www.

Vercel shows DNS records. In GoDaddy (or wherever you bought the domain), update:

A record @ → Vercel's IP (they show the current value)
CNAME www → cname.vercel-dns.com (or what Vercel specifies)

Wait 15–60 minutes. Then check:

Site loads on your domain
Login works (Clerk)
Forms write to Neon
Stripe / Apify still respond

Only cancel Replit after this checklist passes.

What about running out of AI tokens on Cursor?

Fair question — Replit burned me on unpredictable Agent spend.

Cursor Pro is $20/month with an included allowance. If you hit the cap mid-month, you can:

Slow down until the cycle resets, or
Attach your own API key for pay-as-you-go on specific tasks

It's not the same as Replit silently stacking usage into a triple-digit invoice while you're "just fixing one more thing." You see the meter in Cursor's settings.

For migration-sized work (DB swap, auth swap, deploy fixes), budget 2–4 focused sessions of a few hours — not one endless Agent binge.

Monthly cost after migration

Service	Cost
Cursor	$20/mo
Neon	$0 (free tier)
Clerk	$0 (free tier)
Vercel	$0 (free tier)
Domain	~$1/mo amortized if paid yearly
Apify	Same as before (usage)
Stripe	$0 until you charge customers
Total (predictable)	~$20/mo + domain + Apify usage

Compared to $100+/mo on Replit for heavy Agent use, that's the win — not because free tiers are forever, but because you're not paying platform tax on every question.

The upskilling part (why this isn't just cheaper)

Replit trains you to ship inside one box. That's valid.

This migration trains you to own the box:

Git — history, rollback, "what changed?"
.env — secrets discipline (critical before you handle real payments)
Postgres on Neon — same DB you'll see at startups
Clerk — auth you can drop into the next app in an hour
Vercel — how most Next/Node side projects deploy in 2026

You're still a vibe coder. You're just not renting the whole universe from one vendor at premium prices.

Not ready to handle frontend, backend, auth, and Git separately?

Managing each layer on its own isn't for everyone — especially while you're still learning to ship. If you'd rather skip the full migration stack for now, here are a few other alternatives to consider:

1. Stay on Replit

If browser-only workflow fits your brain and you're okay watching usage, Replit is still a legitimate choice — especially for learning and fast prototypes. Use Agent deliberately: batch tasks, write specs, avoid infinite "try again" loops.

If you sign up or extend through a referral: Replit (referral link)

2. Lovable — full-stack from prompts

Closer to "describe the app, get UI + backend scaffolding" without managing Git on day one. Good when you want deployable web apps from natural language and you're okay with their hosting model.

Browse our tools page or start here: Lovable · All tools

3. Bolt or Vercel v0 — speed-first builders

Bolt — full-stack in the browser (StackBlitz WebContainers). Great MVPs, familiar if you liked Replit's "everything in one tab" energy.
Vercel v0 — Vercel's UI generator; excellent when your stack is React/Next and you want polished components fast.

Neither replaces a full auth+DB migration story out of the box the way Neon + Clerk + Vercel does — but for new greenfield ideas, they can keep you shipping without a $100 Replit month.

Full list with referral links where we have them: vibecoderslife.com/tools

Bottom line

I left Replit because per-task Agent billing stopped matching how I work: lots of small questions, lots of iteration, one side project.

I kept Stripe and Apify on the same API keys. I swapped DB → Neon, auth → Clerk, host → Vercel, IDE → Cursor. Predictable cost, transferable skills, same product on the same domain.

If that sounds like your situation, start with secrets export + GitHub verify, then one phase at a time. Don't migrate database and auth in the same hour — finish Neon, test, then Clerk, test, then Vercel.

If frontend, backend, auth, and Git separately sound like a weekend you don't have, stay on Replit or try Lovable, Bolt, or Vercel v0 — ship first, optimize stack later.

Either way, you're building. The goal isn't to win a toolchain debate; it's to stop funding idle Agent loops and fund the product instead.

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Disclosure: Some links above are referral or partner links (marked on our Tools page). I only recommend services I use or would use for vibe coding workflows. Drafting/editing used AI assistance; the migration steps are from my own shipping work.

One month with Codex on ChatGPT Plus (and what I built for OpenAI Ads)

Viktor Kondas — Mon, 21 Sep 2026 09:37:42 +0000

OpenAI put a free month of Plus on my account. I used it for real Codex work — and shipped two tools for ChatGPT Ads while ads rolled into my region.

OpenAI put a free month of ChatGPT Plus on my account. I used it while it was there — mostly inside Codex for real work, not demo scrolling.

Some takes call Codex hype. After a month: it is not. Usage windows and slower completion vs my Cursor + Grok loop annoyed me. Design and architecture? Genuinely strong. Clear answers. Good questions. That part is not marketing fluff.

This is a warm field report: how I installed it, how I routed Sol / Terra / Luna, what I built for OpenAI Ads once ads showed up in Hungary and nearby markets, and where I still open Cursor first.

One line to remember: Sol thinks, Terra builds, Luna finishes — and don't ask Sol to rename a variable.

What Plus actually unlocks for Codex

ChatGPT Plus is $20/month. For Codex specifically, the current public map includes:

Codex on the web, CLI, IDE extension, and iOS
The GPT-5.6 family in Codex: Sol, Terra, Luna
Cloud-side extras (code review / Slack-style integrations where available)
Credits to keep going after included limits

Pro starts higher (from $100/month) with 5× or 20× more Codex usage than Plus. I tested on Plus, not Pro.

OpenAI's own framing (paraphrased from the pricing page):

Model	Use it for
Sol	Hard reasoning, ambiguous problems, advanced coding, high-stakes decisions
Terra	Everyday production work — the workhorse
Luna	Fast, high-volume, focused coding and busywork

Back when GPT-5.6 Sol / Terra / Luna first shipped, access was gated. That chapter is over for paid ChatGPT users — the interesting question now is how you spend the allowance, not whether you can log in.

Every way to run Codex

I lived in VS Code + Codex. You do not have to — pick the surface that matches how you actually work.

IDE extension

Official path: Codex IDE docs

Install / enable Codex for your editor (marketplace download links are on that page — works with VS Code forks like Cursor and Windsurf).
Open the Codex sidebar (or Command Palette → Codex: Open Codex Sidebar).
Sign in with ChatGPT (or an API key).
Keep quick edits local; hand longer jobs to cloud/web when the task outgrows the sidebar.

I chose VS Code + Codex so Cursor stayed clean as my primary IDE. You can also run Codex inside Cursor via the same extension family — I preferred separation.

CLI

Official path: Codex CLI

curl -fsSL https://chatgpt.com/codex/install.sh | sh

Then open a project folder and run codex. First launch: Sign in with ChatGPT.

Handy in-session: /model, /status, /permissions, /init (scaffolds AGENTS.md). Also documented: npm global @openai/codex, Homebrew cask, Windows PowerShell installer — see the CLI page.

Desktop app

Official path: desktop app

Install ChatGPT for Mac / Windows / Linux.
Sign in.
Choose Codex (or ChatGPT, then Chat vs Work).
Start New chat and point it at a folder when you want local files in play.

This is also the on-ramp for computer use, scheduled tasks, and (where available) record-and-replay style workflows.

Mobile remote

Official path: Remote / connections

Codex does not magically run a full agent only on your phone. The pattern is: desktop host stays online, phone steers.

On the Mac/PC: ChatGPT desktop → Settings → Connections → Control this Mac or PC → set up.
Pair with the phone (same ChatGPT account).
From mobile Remote, pick the computer, continue the task, approve commands, review diffs.

Plus includes Codex on iOS in the current pricing list — remote control is how you stay in the loop on the tram without abandoning a long run.

Web Codex

Sign in at ChatGPT / Codex web for cloud tasks and review flows. Local vs cloud share the same agentic allowance; cloud chats often lean on Sol and can burn more of the window than a tight local edit (pricing notes).

My routing: Sol → Terra → Luna

This was my default for the month:

Phase	Model + effort	What I asked for
Think / design	Sol medium–high	Architecture, edge cases, "what would you change?"
Plan / config / most code	Terra medium–high	Specs → implementation, wiring, config
Execute the leftovers	Luna high / max	Tests, README, tidy fixes, "do the next step"

A coaching loop that matched reality:

Sol once for a hard plan (no code yet).
Terra for most of the build.
Luna for the laundry list.
Sol again for a milestone review.

That is close to what I did — I just over-used Sol early because it felt smarter. It is. It is also the fastest way to empty the tank.

Chat vs Work

I brainstormed and designed in Chat. Some people swear by the Work tab for merging spec files into one run. I did not love Work for my style — it felt like an extra surface when an extended Chat thread already had the context.

Dear readers: what are you doing? Chat-native, Work-tab, pure CLI, desktop-only? Tell me. I will steal the good patterns.

Threads beat one giant chat

Advice that matched my month: fresh threads for separate features. A clean context outperforms a 120k-token archaeology dig. Spin parallel threads when the work does not collide; summarize back into one note when you need the map.

Self-scoring loops (define success → agent scores itself → fix until it passes) are useful when you have a clear bar — tests green, computer-use walkthrough, or a reference set. Less magic when "good design" is subjective.

What I built for OpenAI Ads

OpenAI Ads expanded across Europe (Hungary included in Ads Manager availability). I am not an agency. I still wanted something any merchant could run before they paste a feed into Ads Manager.

So I built two Actors (same craft path as how I create Apify Actors people actually pay to use). Codex helped with design and iteration; the Store is how I shipped. This is proof of the month — not the whole story.

OpenAI Ads Readiness Checker

apify.com/kondasviktor/openai-ads-readiness-checker

Evidence scan: HTTPS, robots.txt for OAI-AdsBot (required) and optional OAI-SearchBot, landing/image reachability, optional Merchant feed sample. Independent tool — not affiliated with OpenAI. A green report is not an approval letter.

PPE from the Store page: about $0.15 per domain readiness report (with cheap extra URL checks).

Google Merchant → OpenAI Ads CSV

apify.com/kondasviktor/openai-ads-feed-converter

Takes Google Merchant XML/CSV/TSV/JSON and emits OpenAI Ads canonical CSV with row validation. Verified product-feed markets in the current pin: US / CA / MX. Other countries (including HU) are marked not-yet-verified — we do not fake readiness. v1 downloads CSV; you upload in Ads Manager yourself.

Rough PPE: $0.50 / 1,000 processed product rows.

Want the shipping system for Actors?

Same packaging scars, prompts, and checklists I use before a Store submit — not another scraper tutorial.

The Vibe Coder's Playbook — €37 →

New to Apify? Create an account (referral).

Honest cliffs

Read this before you cancel Cursor.

1) Five-hour windows still exist

You will see takes that "everything is only token credits now." The practical Plus experience is still: five-hour window + weekly limits, then credits if you want to keep going (usage / pricing docs). Model choice and task size change how fast the window drains. Hitting a wall mid-prompt is the worst version of this — worse than Cursor's usual flow for me.

Check /status in the CLI. Check Settings → Usage before a big job.

2) Slower than my Cursor + Grok 4.6 loop

Same class of task often took longer in Codex. Longer runs → more tokens → less allowance left. Quality on design/architecture still impressed me. Throughput is where Cursor won.

3) Long unsupervised runs burn the window

Long unsupervised Terra runs burned my Plus window fast while the job was still only partly done. Great intentions. Bad burn rate for "just execute the checklist."

Takeaway: Codex is excellent as an architect and senior pair. Treat long unsupervised execution like a budget decision, not a default.

4) Stretch the allowance

Official tips that matched reality:

Smaller, precise prompts; less junk context
Lean AGENTS.md; fewer MCP servers when idle
Terra/Luna for routine work
New thread > one endless chat
Credits or a reset if you are eligible and mid-deadline

So… is Codex hype?

No. Sol's reasoning is the real deal for vibe coders who can write a clear brief. Terra is the daily driver. Luna is how you stop lighting money on fire.

Also no: it does not replace my primary IDE. Cursor is still home. Codex is the Plus-powered second brain I open when I want a strong design pass, a CLI agent, or mobile remote on a long job — and when I am shipping something like OpenAI Ads tooling.

If your primary is already Claude Code, Muse, or pure Cursor agents, that is fine. Different harnesses, different walls.

What do you prefer as your primary IDE right now? Reply and tell me — Cursor, Codex, Claude Code, or something weird. I will collect the patterns.

Quick start checklist

Decide surface: IDE sidebar, CLI, or desktop.
Sign in with Plus (or Pro).
/init or write a short AGENTS.md.
Sol once for the hard plan → Terra for the build → Luna for cleanup → Sol for review.
Watch Usage before unsupervised marathon jobs.
If you are staring at ChatGPT Ads: run the readiness checker, then the feed converter if you already have a Merchant feed.

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Sources: Codex pricing & usage; Codex CLI · IDE · desktop app; Using Codex with your ChatGPT plan; Credits for Plus/Pro; ChatGPT Ads expands across Europe; Actors: readiness checker · feed converter; The Vibe Coder's Playbook.

Disclosure: Apify signup is a referral link. OpenAI links are plain product URLs. Actor Store links are my Actors. The Playbook is a soft product mention — no paid placement by OpenAI or Apify for this article. Drafting/editing used AI assistance; the field report and Actors are from my own shipping work.

My first ChatGPT / Codex plugin: saymd

Viktor Kondas — Tue, 15 Sep 2026 16:32:58 +0000

Speak once, get a Markdown prompt any agent can @. Free MIT CLI — now live in the ChatGPT / Codex Plugins directory.

Back on 4 Sep, in the AI image prompt commands newsletter, I teased a VCL project built on Gemini 3.5 Transcribe.

Here I am.

This is also my first product live as a ChatGPT / Codex plugin. Among roughly a thousand third-party plugins, one of them is mine — and I'm excited for you to try it.

Meet saymd — a Free MIT CLI that turns microphone speech (or an audio file) into a structured Markdown prompt any agent can @. Not a raw dump into chat. A usable spec: Objective / Context / Instructions / Constraints (or a feature / bug / plan template).

You bring your own speech-to-text key (BYOK). saymd does not host your audio or sell transcription minutes.

Start-here: npx saymd setup → npx saymd doctor → npx saymd. Then @ .ai/prompt.md in your agent. Site: saymd.app · Free MIT: GitHub.

I still prefer the CLI

I spent years in VS Code. Even with Cursor, Codex, Claude Code, and Antigravity desktop apps on the machine, I still prefer the CLI when I can. Less UI chrome. Faster loops. Feels like home.

The bottleneck is not the agent. It's typing.

Dictation helps. Tools like Wispr Flow and native IDE dictate are great for getting words out of your head. The problem: they usually dump messy unstructured text straight into the chat box. Agents then guess the objective, invent constraints, and miss the acceptance criteria you meant to say.

I wanted the opposite: speak once → get a prompt file I can @ in Cursor, Codex, Claude Code, Gemini CLI, Grok Build, Copilot, OpenCode — whatever I'm using that day.

That's saymd.

What saymd does

You speak (mic) or pass --file idea.m4a.
Your chosen STT provider transcribes (and, for Gemini / OpenAI, helps structure).
saymd writes .ai/prompt.md — structured Markdown, not a transcript paste.
You @ that file in your agent and let it execute.

Default headings (no template): Objective · Context · Instructions · Constraints.

`--template`	Shape
`feature`	Objective, Context, Instructions, Constraints, Acceptance criteria
`bug`	Objective, Context, Steps to reproduce, Expected / Actual
`plan`	Objective, Context, numbered Steps, Constraints, Open questions

Demo from the GitHub repo — mic or --file → structured .ai/prompt.md.

How to run (Free)

npx saymd setup
npx saymd doctor
npx saymd

Or from an existing clip:

npx saymd --file idea.m4a --template feature

Useful flags:

-o .ai/prompt.md — output path
--template feature|bug|plan
--seconds 30 — shorter first test (Free max is ~60s)
--lang hu — language hint if auto-detect misses
--provider gemini|openai|deepgram|elevenlabs

doctor checks ffmpeg, mic, provider, and API key before your first real take. Press Enter to stop recording early — you don't have to wait for the max.

Requirements: Node 20+, ffmpeg, macOS or Linux (Windows: WSL or --file only).

Providers (BYOK — Free)

All four are available on Free. You create the key with the provider, paste it in saymd setup, and pay that provider directly.

Provider	Exact model	Notes
Gemini (recommended)	`gemini-3.5-transcribe`	Speech-to-text and Markdown structuring
OpenAI	`gpt-4o-transcribe`	Speech-to-text and Markdown structuring
Deepgram	`nova-3`	STT only — also needs Gemini or OpenAI to structure
ElevenLabs	`scribe_v2`	STT only — same as Deepgram

Keys live in ~/.saymd/config.json (mode 0600) or env vars (GEMINI_API_KEY, OPENAI_API_KEY, …). A typical ~60s dictation is usually well under $0.01 on your own key (provider pricing applies).

Privacy: API keys stay on your machine. Audio goes only to the STT provider you chose, with your key. saymd.app does not receive your audio, transcripts, or prompt files.

Languages (Free): 85+ input languages with automatic detection. On Free, every section of the Markdown is written in the same language you spoke. Pro unlocks cross-language --out (e.g. speak Hungarian → English Markdown).

When a 60-second take isn't enough

The Free MIT CLI is the whole product for short recordings. Stay there if that's all you need.

If you start using saymd every day — continue a spec after the first take, ask it to flag missing requirements, speak one language and write the Markdown in another, or record past a minute — that's Pro. It's a separate package (@saymd/pro), not a hidden switch in the MIT repo. I sell the year first: €39/year at saymd.app. A monthly option exists if you only want to try; yearly is the one I'd pick.

saymd activate <activation-code>
saymd --continue .ai/prompt.md
saymd --review .ai/prompt.md
saymd --out en

Pro adds:

--continue — add more speech; merge into the same spec
--review — missing requirements, constraints, acceptance criteria
--out — speak one language, write the spec in another
Project vocab via .saymd/vocab.txt
Longer recordings (default 120s, max 10 minutes)

Where saymd runs today

Surface	Status
ChatGPT / Codex	Live in the OpenAI Plugins Directory — among ~1000 ChatGPT plugins, one of them is mine, and I'm genuinely excited
Gemini CLI	`gemini extensions install https://github.com/kondasviktor/saymd`
Grok Build	Available via DIY marketplace add from the README; official catalog PR pending
Claude Code + Cursor	Currently under review for publishing

If you use ChatGPT, search saymd under Plugins in your account. Screenshots below of the live listing — Voice to Markdown prompts.

saymd live in the ChatGPT / Codex Plugins directory.

Install screen — starter @saymd prompts and the Install plugin button.

Slash commands in the plugin package include /saymd, /saymd-feature, /saymd-bug, /saymd-plan, plus Pro-oriented /saymd-continue, /saymd-review, /saymd-out.

Native loop still works everywhere: run the local CLI → @ .ai/prompt.md → offer to implement.

Outgrowing the 60-second Free cap?

Keep the MIT CLI. Add Pro when continue / review / cross-language / longer takes start to matter — €39/year.

Open saymd.app →

Your turn

Try Free: npx saymd setup && npx saymd doctor, then one short recording.
Star the repo: github.com/kondasviktor/saymd — stars help other vibe coders find a Free BYOK voice-to-Markdown CLI.
Share with a friend who dictation-dumps into chat.
Pro when continue / review / longer takes start to matter — €39/year.
Feedback welcome — reply to the newsletter or open an issue. Optional tip jar: Buy Me a Coffee.

If you only remember one line: agents execute; saymd delivers the usable spec.

Quick start checklist

npx saymd setup — pick Gemini (gemini-3.5-transcribe) unless you already live on OpenAI keys.
npx saymd doctor
npx saymd --seconds 30 --template feature
@ .ai/prompt.md in your agent
Optional: install the ChatGPT/Codex plugin or Gemini CLI extension
Optional: Pro at saymd.app → saymd activate <code>

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Sources: saymd.app · GitHub (MIT Free CLI) · Gemini 3.5 Transcribe · ChatGPT / Codex plugin.

Disclosure: Wispr Flow link is a referral. saymd is my product (Free MIT CLI + optional Pro). Buy Me a Coffee is optional support — not required to use Free. Drafting/editing used AI assistance; the product, plugin listing, and CLI are my own shipping work.

How I create Apify Actors people actually pay to use

Viktor Kondas — Tue, 15 Sep 2026 12:05:40 +0000

First Store submit, eight live Actors, the Graveyard, and the Playbook that grew out of the packaging scars.

This is my builder story — not an AI news roundup or a polished case-study brochure. If you have only seen Apify in a tools list, start with the next section.

I used Cursor daily, shipped Actors to the Apify Store, killed ideas that looked good on a whiteboard, and wrote down what hurt so I would not forget it. That became The Vibe Coder's Playbook: Build Apify Actors people will actually pay to use — the same packaging scars, prompts, and checklists I wish I had before my first serious submit. Vibe Coder's Life is where I share the messy parts on purpose.

What is Apify?

Apify is a cloud platform for Actors. An Actor is a packaged scraper or automation: a form for inputs, a cloud run, a dataset (or files) out the other side, optional schedules, and a public listing on the Store.

You do not have to build your own billing, hosting, or "run this job" UI. Buyers pay Apify compute (and your pricing if you charge per event). You iterate the Actor; they rerun it.

That is why vibe coders should care. Most AI-built scrapers die as a local script. The Store is one of the few places an indie can put a real product in front of strangers and get paid without standing up a SaaS. It only works if you treat the Actor like a product — QA-safe defaults, an honest README, pricing that matches what the code actually charges — not a weekend demo.

Why I started building Actors

I did not start from "I should be on the Store." I started from work I already do: find suppliers, check who they are, follow dealer networks, pull public PDFs, notice when a page changes, look at station fuel prices, export a catalog, watch wildfire feeds.

Doing that as a pile of notebooks does not scale. Doing it as Store Actors meant I could rerun the same pipelines, and other people could buy one step without buying the whole suite.

Shipping them also forced the packaging lessons the Playbook is about: Store review, prefills, PPE, READMEs. I would rather share that path than pretend the listings appeared fully formed.

First Actor submit — what actually hurt

My first serious submit taught me more than any Academy skim:

QA-safe prefills matter more than clever crawlers. If the default Store "Try it" run burns time or money, review stalls.
README honesty ("what this score is not") prevents support debt.
PPE events need to match what you actually charge in code — drift feels like a "bug" when it is packaging.
Local green ≠ cloud green. Proxies, timeouts, and memory lie until you smoke on the platform.

That packaging pain is why the toolkit exists: templates, checklists, and prompts aimed at shipping, not inventing another scraper tutorial.

Eight live Actors (and not another Maps clone)

I wanted Actors with a sharp buyer sentence, public pages / open feeds, and wedges that are not "yet another generic scraper." Each listing sells alone; some chain.

Supplier research

Discover → enrich → docs → watch:

Stage	Actor	Store
Discover	Google Maps CEE Scraper — Supplier Shortlist	google-maps-cee-scraper
Channel map	Dealer / Distributor Locator Extractor	dealer-distributor-locator
Enrich	Website Intelligence + Contact Extractor	website-intelligence-contact-extractor
Docs	PDF Procurement Document Extractor	pdf-procurement-document-extractor
Watch	Website Change Monitor — Diff Tracker	website-change-monitor

E-commerce

Stage	Actor	Store
Catalog	Product Catalog Scraper — Shopify CSV, WooCommerce & Shoprenter	product-catalog-scraper

Location intelligence

Stage	Actor	Store
Fuel	European Fuel Station Prices API (CEE + DACH)	cee-dach-fuel-intelligence
Wildfire	Wildfire Intelligence API — US WFIGS + Europe EFFIS	wildfire-intelligence

Maps leads with scoring and CEE language; Dealer targets locator layouts; Website Intel adds impresszum / compliance flags; PDF focuses procurement docs; Monitor closes the loop on public page change; Catalog writes Shopify / Woo / Shoprenter CSV; Fuel normalizes CEE+DACH station prices; Wildfire pulls official US + EU fire feeds.

Typical chain: Maps or Dealer Locator → Website Intel → PDF / Change Monitor. Fuel + wildfire sit beside that as location APIs. Catalog is a separate storefront line.

Profile: apify.com/kondasviktor — eight published Actors at the time of writing.

The Graveyard — what I did not build

Sharing failures is the point of Vibe Coder's Life.

I killed a media / video downloader path: Store saturation plus copyright surface that is not the same category as public business facts. I walked away from capital-heavy sovereignty / routing gateway ideas that need infrastructure budget I do not have. Store research also rejected trade-show booth scrapers (DOM churn), finite SaaS partner directories (no recurring run), and head-on LinkedIn/job clones.

Saturated platforms (YouTube / Instagram / Amazon / Booking-style clones) look like demand and behave like maintenance and ToS traps for indie publishers. The Playbook's Graveyard chapter is that judgment written down — what to build instead.

What worked vs what broke

Worked: suite cross-links without forcing a monolith; BYOK AI off by default; deterministic value first; example tasks named for humans; public-data framing in READMEs.

Broke / burned time: language-specific Maps DOM labels; prefills that were too heavy for QA; README drafts that read like feature dumps; underestimating proxy cost vs event price.

Those notes became checklists and prompts — not motivational filler.

The toolkit that grew out of this

I did not set out to sell a PDF. I set out to stop re-explaining the same Store packaging mistakes in DMs.

The Vibe Coder's Playbook: Build Apify Actors people will actually pay to use is the system behind the story above:

104-page playbook — validation, PPE economics, Crawlee, Cursor workflows, Store SEO, pricing, Graveyard judgment, case studies
100 Actor ideas (CSV + Markdown) with difficulty and maintenance ratings
80+ AI prompts + shared constraints so assistants stop inventing APIs
Runnable TypeScript starter Actor (books.toscrape.com demo — not my production Store scrapers)
Templates, worksheets, and launch checklists

€37 once · personal download by email after Stripe Checkout · no subscription.

The post is the journey. The toolkit is the repeatable shipping loop — buyer sentence → Graveyard check → PPE model → QA-safe schema → cloud smoke → Store packaging.

No fake urgency. If this story resonated and you want the files, start there:

Explore the toolkit — €37 →

Start building

Create an Apify account (referral) if you are new to the platform.
Browse the Actors above — steal the patterns, not necessarily the niches.
If you buy the toolkit, open START-HERE.md first inside the zip.

If you need help beyond the toolkit — a quick Actor review, a fixed-price Starter Actor, custom multi-Actor work, or maintenance after launch — email hello@vibecoderslife.com. Happy to support when it is useful; no pressure either way.

Originally published on Vibe Coder's Life. I send a short Tuesday/Friday digest on AI coding tools and shipping with agents — subscribe.

Sources: Apify Store profile (eight live Actors); Apify docs; The Vibe Coder's Playbook.

Giving AI agents live European fuel prices with Apify MCP

Viktor Kondas — Mon, 14 Sep 2026 15:45:05 +0000

Giving AI agents live European fuel prices with Apify MCP

How I turned a CEE + DACH fuel-price Actor into a tool Cursor can call — and what I had to change once a model, not a spreadsheet, was reading the output.

I built European Fuel Station Prices API (CEE + DACH) (https://apify.com/kondasviktor/cee-dach-fuel-intelligence) as a normal Apify Actor first: normalized station prices across Central Europe and DACH, scheduled monitoring, and a route cheapest-stop mode. Then I wired the same Actor into Cursor through the Apify MCP server (https://docs.apify.com/platform/integrations/mcp). This piece is about that second step — Theme 2 in Apify's Content Program: your Actor as a tool for AI agents.

What you need

A free Apify (https://apify.com) account
Cursor (https://cursor.com) (or another MCP-capable client)
Willingness to let the agent call cloud Actors (each run bills PPE; Austria smoke tests land on the $0.10 minimum)
Optional: a Fuelo (https://fuelo.net/about/api\_key\_request) API key if you want HU/PL/CZ/SK/CH/BG coverage (BYOK — the Actor never uses platform keys)

No local scrape setup. The Actor already runs on Apify; MCP is how the agent reaches it.

The guessing problem

Ask any LLM-based agent "where should I fill up between Budapest and Vienna?" and you get a fluent answer built from training data that is months or years stale. Pump prices move daily. Logistics teams want live, per-station, cross-border numbers — not a national average from memory.

CEE adds a second failure mode. Slovakia can apply dual pricing for foreign-plated vehicles (dualPricingForForeignPlates: true, verified 2026-07-24 in my Actor's regulatory config). Croatia can run price caps on regular stations while highway stations differ (priceCapActive: true, same date). Austria restricts when prices may increase to Mon/Wed/Fri (priceIncreaseRestrictedDays: ["MO","WE","FR"]). None of that belongs in model weights. It belongs in structured fields an agent reads at call time.

That gap — volatile, jurisdiction-specific data an LLM cannot reliably know — is what MCP tools are for. The interesting engineering is not scraping a price board. It is designing output so an agent knows how much to trust each number and receives few enough tokens to reason.

Why I built a regional Actor in Cursor

I live in CEE. The Apify Store had US/FR/AU fuel Actors; station-level CEE + DACH coverage did not. I wanted one schema across DE, AT, CH, HU, PL, CZ, SK, RO, HR, SI, and BG — official feeds where they exist, licensed aggregators elsewhere, EUR-normalized for cross-border comparison.

The Actor is live on Store (build 0.1.10 at time of writing), pay-per-event (https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event), with public example tasks. No buyer key for AT, SI, HR, RO. BYOK: Tankerkönig for DE, Fuelo for CH/HU/PL/CZ/SK/BG. You can smoke-test Austria in under a minute for the $0.10 minimum run charge.

I built the Actor in Cursor — the same client that now calls it via MCP. That closed loop mattered: every schema tweak got exercised by an agent that actually had to answer a logistics question, not by me staring at a dataset table.

Data sources are official public APIs or licensed aggregators with BYOK. The Actor does not scrape pump websites behind a login or ignore site terms; for Poland and similar Fuelo countries, missing a key fails loudly instead of inventing prices.

How the Actor is built

Each country is a small adapter behind one interface. Austria reads E-Control's public JSON API, maps DIE/SUP/GAS into canonical diesel/petrol95/cng, and tags every row dataConfidence: OFFICIAL_REALTIME with an honest sourceMessage that E-Control returns cheapest-N, not the full market:

Code (typescript)

// src/adapters/at.ts (excerpt)

url.searchParams.set('fuelType', mapFuel(query.fuel));

// ...

return {

stationId: s.id != null ? String(s.id) : null,

country: 'AT',

diesel: typeof die === 'number' ? die : null,

petrol95: typeof sup === 'number' ? sup : null,

dataConfidence: 'OFFICIAL_REALTIME',

source: 'E-Control Spritpreisrechner',

sourceMessage:

'E-Control returns cheapest-N stations for the search — not every station nationwide',

regulatoryFlags: regulatoryFlagsFor('AT'),

};

Prices pass through ECB FX into *Eur and priceEur so a Budapest→Vienna comparison is not HUF guesswork against EUR memory.

Route mode keeps cheapest-stop math deterministic — haversine detour, not LLM arithmetic:

Code (typescript)

// src/route/geometry.ts (excerpt)

const detour = toStation + stationToDest - direct;

if (detour > opts.maxDetourKm) continue;

if (!best || price < best.price || (price === best.price && detour < best.detour)) {

best = { station: s, price, detour, fromOrigin: toStation };

}

Partial runs never invent rows. markCountryStatus classifies each country (ok, empty, missing_fuelo_key, …) and the run still succeeds for the rest:

Code (typescript)

// src/main.ts (excerpt)

if (errMsg) {

countryStatus[country] = classifyAdapterError(errMsg).status;

return;

}

Pricing is explicit PPE: station-price $0.0025, route-recommendation $0.05, optional ai-digest $0.15 (BYOK, off by default), $0.10 minimum per run.

Architecture: agent decides, Actor evidences

Code (text)

User question

→ Cursor agent

→ Apify MCP (call-actor / fetch-actor-details)

→ Fuel Intelligence Actor

→ country adapters → live feeds

→ normalized dataset

→ agent recommendation

The agent is the decision layer. The Actor is the evidence layer. MCP is the bridge that removes the manual Console handoff.

Wiring Cursor to Apify MCP

Apify hosts MCP at https://mcp.apify.com with OAuth on first connect — no API token in your config file. In .cursor/mcp.json:

Code (json)

{

"mcpServers": {

"apify": {

"url": "https://mcp.apify.com/?tools=fetch-actor-details,kondasviktor/cee-dach-fuel-intelligence"

}

}

}

That pin matches the snippet on the Actor's Store page: fetch-actor-details plus the Actor id. For day-to-day exploration I also use a broader pin (actors,docs,...) so the agent can search Store and read docs; for a fleet assistant that always calls this Actor, the narrow pin skips a search round trip.

Reload Cursor, sign in to Apify when prompted, then enable the server under Settings → Tools & MCP.

Cursor MCP configuration in mcp.json showing the Apify server URL with the cee-dach-fuel-intelligence Actor pinned as a tool

Cursor MCP tool list for the Apify server — all tools enabled including kondasviktor/cee-dach-fuel-intelligence

Typical discovery path: search-actors → fetch-actor-details (read the input schema (https://docs.apify.com/platform/actors/development/actor-definition/input-schema)) → call-actor. The input schema tells the agent required fields (mode, lat/lng for point, origin/destination for route). Apify can also infer output shapes from recent successful runs; my Actor's dataset schema documents row types (station-price, route-recommendation, run-status). The Actor output schema in Console is mainly deep links (dataset, runOverview) — field typing for agents comes from input + dataset schemas, not from those links alone.

Three real agent runs (August 2026)

I did not tell the agent "run my fuel Actor." I asked logistics questions and let it resolve the tool through MCP. All runs below are cloud runs via Apify MCP; run IDs are real. Origin in Console shows MCP.

A — Vienna petrol, key-free official data

Prompt: I need current petrol prices near central Vienna for a delivery van, and tell me how reliable that data is.

Input the agent constructed:

Code (json)

{

"mode": "point",

"countries": ["AT"],

"lat": 48.2082,

"lng": 16.3738,

"radiusKm": 8,

"fuel": "petrol95",

"maxStations": 8,

"enableAIDigest": false

}

Run: chJk2dCvN45DnWGKC · SUCCEEDED in 4.5s · 10 dataset items · countryStatus.AT: ok

Cheapest row returned:

Code (json)

{

"recordType": "station-price",

"stationId": "1494440",

"brand": "TMC",

"name": "TMC Werkstatt & Tankstelle",

"country": "AT",

"city": "Wien",

"petrol95": 1.669,

"petrol95Eur": 1.669,

"priceEur": 1.669,

"currency": "EUR",

"dataConfidence": "OFFICIAL_REALTIME",

"source": "E-Control Spritpreisrechner",

"sourceStatus": "OK"

}

Agent conclusion: TMC at €1.669 is the cheapest nearby petrol95; data is official E-Control realtime, but cheapest-N — not every Austrian station.

Scenario A run detail in Apify Console — run chJk2dCvN45DnWGKC, SUCCEEDED, 10 results, origin MCP

Scenario A dataset — Vienna petrol95 station-price rows sorted by price, TMC first at €1.669, all with OFFICIAL_REALTIME confidence

B — Budapest→Vienna diesel route

Prompt: I'm driving a diesel van from Budapest to Vienna today. Where should I stop to fill up without a big detour, and how sure are you about that price?

Input (Fuelo key redacted — buyers supply their own):

Code (json)

{

"mode": "route",

"countries": ["HU", "AT"],

"originLat": 47.4979,

"originLng": 19.0402,

"destinationLat": 48.2082,

"destinationLng": 16.3738,

"fuel": "diesel",

"maxDetourKm": 20,

"maxStations": 25,

"radiusKm": 15,

"enableAIDigest": false,

"fueloApiKey": "YOUR_FUELO_KEY"

}

Run: mT6vN8TOsCG7P5d6s · SUCCEEDED in 12.9s · 39 items · one route-recommendation row

Code (json)

{

"recordType": "route-recommendation",

"stationId": "fuelo:HU:36084",

"brand": "Slovnaft",

"country": "HU",

"city": "Bratislava",

"fuel": "diesel",

"price": 1.706,

"priceEur": 1.706,

"currency": "EUR",

"distanceFromOriginKm": 158.38,

"estimatedDetourKm": 1.03,

"dataConfidence": "COMMUNITY_AGGREGATOR_UNVERIFIED"

}

Agent conclusion: Cheapest stop within ~1 km detour is Slovnaft diesel at €1.706 — but the agent must hedge: COMMUNITY_AGGREGATOR_UNVERIFIED, not official regulator data. The same run also returned OFFICIAL_REALTIME E-Control rows for AT segments; mixing tiers in one answer without naming confidence would be wrong.

This is token economics in practice: route mode returns one recommendation record plus bounded station rows (maxStations), not an unbounded national dump. MCP still returns full field lists per row — context control is the Actor's modes and caps, not automatic truncation in MCP.

Scenario B dataset — Budapest-Vienna route, row 42 is the route-recommendation: Slovnaft Bratislava, diesel €1.706, ~1.03 km detour

C — Poland without a Fuelo key (honest failure)

Prompt: Current diesel near central Warsaw — same kind of answer as Vienna.

Input: point query for PL — fueloApiKey deliberately omitted even though I have a key locally.

Code (json)

{

"mode": "point",

"countries": ["PL"],

"lat": 52.2297,

"lng": 21.0122,

"radiusKm": 10,

"fuel": "diesel",

"maxStations": 10,

"enableAIDigest": false

}

Run: RJCT720eHg3INuOzg · SUCCEEDED in 3.6s · 0 stations · 1 run-status row

Code (json)

{

"recordType": "run-status",

"countryStatus": { "PL": "missing_fuelo_key" },

"stationCount": 0,

"okStationCount": 0,

"notes": [

"PL: PL uses Fuelo.net (BYOK). Set input fueloApiKey from https://fuelo.net/about/api\_key\_request — we never use platform keys."

]

}

Agent conclusion: Polish station data is unavailable until the caller supplies a Fuelo key — do not invent Warsaw diesel prices. Honest failure beats silent emptiness: the run succeeded, the status says why it is empty.

Scenario C run detail — run RJCT720eHg3INuOzg, SUCCEEDED with 1 result, origin MCP, completed in 3 seconds

Scenario C Actor log — ERROR line shows PL uses Fuelo.net BYOK, followed by INFO: stations=0, status=missing_fuelo_key

What MCP removed

Without MCP, a human (or agent pretending to be one) does this:

Open Apify Console
Find the Actor
Fill input JSON
Start run
Wait
Open dataset
Export or copy rows
Paste into chat
Ask the model to recommend

With MCP, steps 2–8 collapse into one agent turn: recognize live fuel data is needed → fetch-actor-details → call-actor → reason on structured rows. The manual handoff disappears.

Design choices that mattered for agents

A few patterns I would steal for any live-data Actor meant for MCP:

Put provenance on the row, not only in the README. dataConfidence, source, and sourceMessage ride on every station row so the agent can hedge inside one tool call. A spreadsheet buyer scrolls to methodology; an agent cannot.

Keep regulation in dated config, not model memory. regulatoryFlags come from JSON (lastVerified: 2026-07-24). The optional ai-digest PPE event stays off the hot path — narrative over aggregates is for scheduled batch runs, not every "where's cheapest" query.

Keep the core deterministic. Currency normalization, detour math, and cheapest-stop selection stay in TypeScript. Let the agent interpret; do not let it calculate pump prices.

Name fields so a model can infer meaning. estimatedDetourKm and missing_fuelo_key beat internal enums like tier2.

Design for agent call patterns. One route call beats eleven country calls. Cap maxStations. Batch countries in a single input when the schema allows it.

What broke while building this

AT always needs coordinates. Even country mode feeds a national centroid into E-Control's lat/lng search — there is no "whole country" dump.
asOfDate on E-Control throws explicitly when asOfDateStrict=true instead of silently serving live prices as history.
Tankerkönig free tier caps radius at 25 km — the input schema enforces the same cap.
Missing BYOK must not look like "no stations exist." Poland without fueloApiKey → missing_fuelo_key, not an empty success story.
Early MCP pins that only exposed call-actor without fetch-actor-details made the agent guess required fields. Pinning the Actor and details fixed that.

What I would do differently

I would ship the dataset schema and dataConfidence enums before the first public Store listing. I added provenance after watching an agent treat a Fuelo community price like E-Control realtime. I would also document MCP pin recipes on the Store page earlier — the narrow pin vs broad actors,docs pin is not obvious from Console alone.

Next on my list: richer route geometry than haversine (road network detours), and clearer city/country consistency checks when a community feed returns odd location labels.

Takeaways

One Actor now serves Console, API, schedules, automation tools — and agents via MCP. Fuel was the forcing function because bad answers are costly; the pattern generalizes to any live, messy, geographic dataset (EV charging, truck parking, tolls): normalize in the Actor, expose provenance on every row, keep math deterministic, let MCP handle the call, let the agent handle the question.

Try it: European Fuel Station Prices API (CEE + DACH) (https://apify.com/kondasviktor/cee-dach-fuel-intelligence) — AT/SI/HR/RO need no key. MCP setup: Apify MCP docs (https://docs.apify.com/platform/integrations/mcp).

Viktor Kondas · [Apify profile](https://apify.com/kondasviktor) · Built in Cursor with Apify MCP