Vercel Got Hacked (April 2026): The 60-Minute Emergency Playbook Every Developer Needs to Run Today

On April 19, 2026, Vercel confirmed that attackers compromised a third-party AI tool (Context.ai), hijacked a Vercel employee's Google Workspace account, and read environment variables that weren't marked "sensitive" across a limited subset of customer projects. If you deployed anything to Vercel in the last 30 days, you need to assume one of your env vars may already be in someone else's hands — and you need to move fast.

Here's the uncomfortable truth: most vibecoders ship .env values straight from a template without ever touching the "sensitive" toggle. That's exactly the class of variable the attacker read. This playbook walks you through the next 60 minutes — what to check, what to rotate, and how to harden your stack so the next platform breach doesn't break your app.

TL;DR: What to Do in the Next 60 Minutes

If you read nothing else, do these six things right now:

1. Pause auto-deploys on your production branches.
2. Run vercel env pull and grep the output for secret patterns (sk_live_, AKIA, ghp_, eyJ).
3. Rotate every API key stored as a non-sensitive env var — start with payments, database, auth, and cloud provider keys.
4. Re-add rotated secrets using Vercel's "Sensitive" environment variable toggle, then re-deploy.
5. Open your Vercel activity log for April 1–20 and flag any deployment, login, or token event you don't recognize.
6. Review your GitHub org audit log for the same window — new PATs, deploy keys, or workflow changes.

Below is the full breakdown, with the commands, patterns, and rotation order you'll need.

What Actually Happened in the Vercel April 2026 Breach?

Vercel disclosed on April 19, 2026 that an attacker compromised Context.ai, a third-party AI productivity tool used by a Vercel employee. From there, the attacker took over the employee's Vercel Google Workspace account, pivoted into Vercel's internal environment, and accessed environment variables that were not flagged as "sensitive."

Variables marked "sensitive" use a separate encrypted read path, and Vercel says there's no evidence those were exposed. Everything else — regular env vars storing API keys, database URLs, JWT secrets — was readable. A cybercrime forum post has since claimed to be selling Vercel data for $2 million, though Vercel hasn't confirmed exfiltration. Either way, the safe move is to assume compromise for rotation purposes, even if Vercel hasn't emailed you directly.

The company assessed the attacker as "highly sophisticated based on their operational velocity and detailed understanding of Vercel's systems." Translation: this wasn't a script kiddie — treat the clock seriously.

Are You Affected? How to Check in 5 Minutes

Short answer: if you use Vercel and you haven't been religious about the "Sensitive" toggle, treat yourself as affected. Here's the 5-minute triage:

• Open Vercel's activity log and filter from April 1, 2026 to now. Look for unfamiliar logins, token creations, or deployments.
• Go to Google Workspace Admin → Security → API Controls and search for the published indicator of compromise: the OAuth client ID 110671459871-30f1spbu0hptbs60cb4vsmv79i7bbvqj.apps.googleusercontent.com. If it's authorized, revoke it immediately.
• Check if anyone on your team has ever logged into Context.ai using Google SSO. If yes, treat their accounts as higher-risk.
• Look at your Vercel project's Environment Variables tab. Count how many are NOT marked "Sensitive." Every one of those is in scope.

If you got an email from Vercel starting with "We identified a security incident affecting your account" — you're in the confirmed-impacted bucket. Skip to the rotation section and start NOW.

The 60-Minute Emergency Response Playbook

This is ordered by blast radius. Do not skip steps — each one unblocks the next.

Step 1: Freeze the Environment (First 10 Minutes)

Stop the bleeding before you start the forensics:

• Pause auto-deploys on main / production branches (Vercel Dashboard → Project → Settings → Git).
• Temporarily disable the Vercel GitHub App at github.com/organizations/<your-org>/settings/installations if you suspect deeper compromise.
• Export your Vercel audit log to a CSV and save it locally. You'll need it if this turns into a GDPR-notifiable incident later.
• Enable Observability Plus (even a trial week) so you retain extended logs.

This is the "preserve evidence" step. Rotating before you snapshot the log destroys your timeline.

Step 2: Pull Env Vars and Scan Them for Secrets

Open your terminal and run:

vercel link
vercel env pull .env.vercel-audit

Then scan the output. The fastest way is GitGuardian's CLI:

ggshield secret scan path .env.vercel-audit

If you don't want to install anything, grep for these patterns — they catch 80% of leaked secrets in env files:

grep -E "AKIA[0-9A-Z]{16}|sk_live_[0-9a-zA-Z]{24}|ghp_[0-9a-zA-Z]{36}|ghs_[0-9a-zA-Z]{36}|npm_[0-9a-zA-Z]{36}|eyJ[a-zA-Z0-9_-]+|-----BEGIN" .env.vercel-audit

Every match is a rotation candidate. Every unmatched secret that's still a credential (DB URLs, Redis passwords, webhook signing keys) is ALSO a rotation candidate — the grep just catches the obvious stuff.

Step 3: Rotate Secrets in Priority Order (Not Alphabetical)

This is where most teams screw up. They rotate 40 secrets in random order, a session key invalidates every active login, and support tickets explode. Do it in tiers:

Tier 0 — Rotate in the next 30 minutes:

• All GitHub Personal Access Tokens (fine-grained and classic)
• All existing Vercel sensitive env var tokens
• Deployment Protection tokens

Tier 1 — Rotate today:

• Payment processor secret keys (Stripe sk_live_, Adyen, Braintree)
• AUTH_SECRET, NEXTAUTH_SECRET, JWT signing keys, session cookies
• Database connection strings with write access (DATABASE_URL, Mongo, Redis)
• Cloud provider keys (AWS IAM, GCP service accounts, Azure client secrets)
• Webhook signing secrets (update at sender AND receiver)

Tier 2 — Rotate this week:

• Third-party SaaS keys (email, SMS, analytics, CRM)
• OAuth client secrets
• SMTP credentials, CDN keys

Tier 3 — Rotate when convenient:

• Read-only analytics tokens, Sentry DSNs, public/anon keys

Critical order-of-operations:

• For databases: create the new user before revoking the old one, or you'll take the site down mid-rotation.
• For session keys: plan a logout event — every active session dies.
• For webhooks: update both sides in the same deploy window.
• Re-deploy after every env var change. Vercel bakes values at build time, not runtime.

Step 4: Re-add Everything as "Sensitive"

When you put the new values back, flip the "Sensitive" toggle on every single one. Sensitive values use a separate encrypted path and, per Vercel's own bulletin, were not exposed in this incident. This is the one-click change that would've saved most affected customers.

Step 5: Audit Your Repo for Unwanted Changes

Compare HEAD on your main branch against a known-good commit from before April 1. Focus on:

• package.json scripts — especially postinstall, prepare, preinstall
• Lockfiles (package-lock.json, pnpm-lock.yaml) for unexpected new dependencies
• .github/workflows/*.yml for new workflows or unpinned actions
• vercel.json for build command changes or suspicious rewrites
• next.config.js for new headers or redirects pointing to unknown domains

If you publish npm packages, also run npm view <pkg> time --json and verify nothing shipped that you didn't author.

Step 6: Hunt Downstream

Attackers don't stop at env vars — they use them. Query your downstream systems for the window April 1–present:

• AWS CloudTrail: unexpected CreateUser, AttachUserPolicy, S3 GetObject bursts, logins from new IPs.
• Database audit logs: large SELECT * queries, exports, connections from unusual regions.
• Stripe / Adyen: new API keys, suspicious refunds, customer creations from odd locations.
• Auth provider: impossible-travel logins, unauthorized password resets, new OAuth apps.

Any hit here turns this from a rotation exercise into an actual incident — escalate and consider notification obligations (GDPR: 72 hours).

What "Vibecoders" Miss: The Hidden Attack Surface

If you came up through AI-assisted coding — using tools like Claude Code, Cursor, or Copilot — you probably shipped your first Vercel app before you ever read a security doc. That's fine. But there are four hidden traps that hit vibecoders harder than they hit seasoned devs:

1. The NEXT_PUBLIC_ footgun. Anything prefixed NEXT_PUBLIC_ gets bundled into the client JavaScript. If you stuck an API key in there "just to test," it was already public before the breach. Grep your built output: grep -rE "sk_|AKIA|eyJ" .next/static/.
2. The Linear / Slack leak. If your team pastes secrets into Linear issues or Slack threads "just for a second," those secrets sit in third-party logs. Review your Linear audit log and search for the same regex patterns above.
3. The .env.local in private repo assumption. Private repos aren't private if your Vercel GitHub App was compromised. Every committed .env.* file is in scope.
4. Preview deploys with prod secrets. Most vibecoders reuse production env vars for preview environments. That doubles your attack surface. Separate them.

This is the boring infrastructure work that AI coding tools skip over. The fix isn't to stop using AI — it's to pair AI speed with a security baseline. If you're still figuring out where your app even lives, our Vercel vs Netlify comparison and Railway vs Render vs Fly.io breakdown are good starting points.

How to Harden Your Stack So the Next Breach Doesn't Burn You

Platform breaches are a when, not an if. Here's the baseline every production app should have in place by Monday:

• Default every new env var to "Sensitive" in Vercel. Make it your team's muscle memory.
• Use short-lived credentials. Swap long-lived AWS/GCP keys for GitHub OIDC federation — your cloud provider trusts the CI identity directly, no long-lived secret to leak.
• Install pre-commit secret scanning (gitleaks, Trufflehog). Stops secrets from entering the repo in the first place.
• Restrict your GitHub App to specific repos, not org-wide.
• Quarterly OAuth app review across Google Workspace, Microsoft 365, GitHub, and Vercel. Kill anything you don't recognize.
• **Run secret scans as a **Claude Code hook — deterministic pre-commit enforcement even when the AI forgets.
• Pin your Next.js version and monitor advisories. Vercel is the primary Next.js steward, so incidents here cascade.
• Segment your backend secrets. If you're using Supabase or Firebase, use row-level security and service-role keys sparingly — a leaked service key is a full DB compromise.

Need Help Locking This Down? Here's How Techsy Fits In

Here's the honest pitch: most small teams don't have a security engineer, and reading a 60-step incident response playbook at 2am is not how anyone wants to spend their Monday.

At Techsy, we've run incident response and platform hardening for 40+ production Next.js and Node.js apps over the past two years. For the Vercel incident specifically, we're offering:

• 72-Hour Emergency Response — We execute the Tier 0 / Tier 1 rotation, scan your env vars against 200+ secret signatures, and audit your Vercel + GitHub + cloud logs end-to-end. Typical turnaround: one working day.
• Platform Hardening Audit — Sensitive-variable migration, OIDC credential rotation, pre-commit secret scanning, GitHub App scoping, and a written runbook so your future-self knows what to do during the next breach.
• Ongoing DevSecOps — Quarterly OAuth reviews, continuous secret scanning, and incident drills so "it won't happen to us" becomes a claim you can actually back up.

We're engineers, not a checkbox security vendor. If you're panicking right now, get in touch for a free 30-minute triage call — we'll tell you honestly whether you need us or whether you can handle it with the playbook above.

Frequently Asked Questions

Is the Vercel hack confirmed real or just a rumor?

Confirmed. Vercel published an official security bulletin on April 19, 2026, acknowledging unauthorized access via a compromised third-party AI tool (Context.ai) and a hijacked employee Google Workspace account. Environment variables not marked "sensitive" were accessed. A separate BreachForums post claims to be selling the data for $2M; that part is unverified.

I didn't get an email from Vercel. Am I safe?

Probably, but "probably" isn't a security posture. Vercel said it contacted the limited subset of customers with confirmed impact. If your email didn't arrive, your risk is lower — but every non-sensitive env var across Vercel's platform was in the blast radius. Do the 10-minute triage above anyway.

What's the difference between "sensitive" and regular env vars in Vercel?

"Sensitive" environment variables use a separate encrypted read path and cannot be viewed in the dashboard after creation. Regular env vars are readable by anyone with project access (including, in this incident, the attacker). The fix is free and takes one click per variable.

Do I need to rotate ALL my secrets, or only the ones on Vercel?

Rotate every secret stored in a non-sensitive Vercel env var. If you used the same key elsewhere (a common anti-pattern), rotate it everywhere. Don't forget .env.local in preview deployments, CI systems like GitHub Actions, and any pasted references in Linear or Slack.

How do I scan my env vars for actual secrets quickly?

Run vercel env pull .env.audit then ggshield secret scan path .env.audit. If you can't install GitGuardian, use the grep one-liner in Step 2 of the playbook — it catches AWS keys, Stripe keys, GitHub tokens, npm tokens, JWTs, and PEM blocks.

Should I switch away from Vercel after this?

Not because of this incident alone. Vercel's response — public IoC, timeline, rotation guidance — has been reasonably transparent. Every platform will have a breach eventually. What matters is whether you've designed for it: sensitive-variable defaults, short-lived credentials, segmented environments. If you're weighing alternatives anyway, our Vercel vs Netlify and Railway vs Render vs Fly.io posts break down the tradeoffs.

How long do I have to notify customers if I'm affected?

GDPR gives you 72 hours from awareness of a notifiable breach. California (CCPA) has data-class-specific triggers. SOC 2 / ISO 27001 contracts often require earlier notice than regulators. If you have paying customers and you confirm exfiltration of their data, assume you're on a 72-hour clock and consult legal before sending anything.

Can Next.js apps be attacked through this even if I'm not on Vercel?

The incident is Vercel platform-specific. Next.js itself, hosted elsewhere, isn't affected by the breach mechanism. But if you used the same NEXT_PUBLIC_ env var patterns that accidentally expose secrets, those problems travel with your code regardless of host. Audit your build output either way.

What's the one-click fix that would have prevented most damage?

Marking every credential-containing env var as "Sensitive" in Vercel from day one. It's a checkbox in the dashboard. In this incident, sensitive variables were NOT accessed — only regular ones were. That's the fix, and it costs zero dollars and roughly five minutes per project.

How do I make sure my team never ships an unmarked secret again?

Three layers: (1) pre-commit secret scanning with gitleaks, (2) a CI check that fails if an env var is added without the sensitive: true flag via the Vercel API, and (3) a Claude Code hook that runs the scanner on every edit. Defense in depth — any one of the three catches 80%, all three catch ~99%.

The Bottom Line

The Vercel April 2026 breach is bad, but it's survivable — if you move in the next 60 minutes. Freeze deploys, pull your env vars, run the grep, rotate in tiers, re-add as sensitive, and hunt downstream. That's the whole playbook.

Platform breaches expose how much we rely on defaults. Most teams who got hurt here did nothing wrong — they just left the "Sensitive" toggle unchecked because nobody told them it mattered. That's the real lesson for vibecoders: AI-generated code ships fast, but security defaults don't come with the generation.

If you want a second pair of eyes on your stack, or you'd rather not execute this playbook solo at 2am, book a free triage call with the Techsy team. Otherwise — good luck, move fast, and mark those variables sensitive.