How to Bypass ngrok's Interstitial Warning Page in 2026 (Without Paying $10/mo)

If you’ve spent any time tunneling a local server through ngrok, you’ve probably hit the interstitial warning screen: you fire up a tunnel to share your localhost with a client or test a webhook, and instead of your app, you get a splash page demanding a click on “Visit Site” before anything loads.

For a human clicking a link, that’s a minor annoyance. For anything automated, it’s a wall. ngrok’s forced interstitial page on free-tier HTML requests routinely breaks headless browser tests, mobile app testing, hot-reloading dev servers, and any webhook provider that can’t click through a warning screen.

This guide covers every practical way to bypass the interstitial in 2026 — from a one-line header to switching tools entirely — and fact-checks the current state of the main ngrok alternatives, since a lot of the “ngrok alternative” content circulating right now gets pricing and feature details wrong.

Why ngrok Shows the Interstitial Page

This isn’t a bug — it’s deliberate. Free ngrok URLs give anyone a temporary, masked HTTPS endpoint, which made the free tier a convenient vehicle for phishing and malware distribution. To cut down on that abuse, ngrok shows an interstitial page in front of all HTML browser traffic on the free tier, telling visitors the site is served by ngrok. Once a visitor clicks through, a cookie suppresses the page for that domain for 7 days — but that doesn’t help a webhook provider or a CI runner that never gets to click anything.

Developers sometimes read a second motive into it too — that the warning conveniently nudges free users toward a paid plan. ngrok doesn’t frame it that way publicly, but it’s worth noting as context: the interstitial does not affect anyone accessing endpoints programmatically or via an API client, only HTML browser traffic.

Where the Warning Page Actually Breaks Things

Headless browsers and E2E tests. Playwright, Puppeteer, and Cypress navigate to your tunnel URL expecting your app’s DOM. They get the ngrok splash page instead, don’t know to click “Visit Site,” and the test times out.

Hot-reloading. Vite, Next.js, and Webpack Dev Server push live changes over WebSockets. The interstitial gets in front of the initial handshake, HMR silently fails, and you’re back to manually refreshing.

Third-party webhooks. Stripe, GitHub, and Twilio all expect an immediate 200 with JSON. If they get HTML instead, the webhook fails, and providers like Stripe will retry aggressively before disabling the endpoint after repeated failures.

Method 1: Bypass It Programmatically

ngrok documents two supported bypass methods that don’t require upgrading:

Send the skip-warning header. Set and send an ngrok-skip-browser-warning request header with any value, and the interstitial won’t show.

curl -H "ngrok-skip-browser-warning: true" https://your-random-url.ngrok-free.app/api/data

// Axios
axios.get('https://your-random-url.ngrok-free.app/api/data', {
  headers: { 'ngrok-skip-browser-warning': 'true' }
}).then(response => console.log(response.data));

import requests
response = requests.get(
    "https://your-random-url.ngrok-free.app/api/data",
    headers={"ngrok-skip-browser-warning": "true"}
)
print(response.json())

Change the User-Agent. Setting a non-standard User-Agent also bypasses the warning, since ngrok’s detection targets standard browser signatures:

// Puppeteer
const page = await browser.newPage();
await page.setUserAgent('MyAutomatedTestingScript/1.0');
await page.goto('https://your-random-url.ngrok-free.app');

For manual browser testing, a header-injection extension like ModHeader works the same way — add a rule that sets ngrok-skip-browser-warning: true on requests to *.ngrok-free.app.

The limit of this approach: it only works when you control the client. You can’t ask Stripe or GitHub to add a custom header to their webhook payload, so this method doesn’t help for third-party webhook delivery.

Method 2: A Self-Hosted Forward Proxy

For webhooks you can’t modify, some developers front the tunnel with a small proxy that injects the header for them. One example is igops/ngrok-skip-browser-warning, an Nginx-based HTTPS forward proxy with full SSL, WebSocket, SSE, and CORS support that automatically adds the skip-warning header before forwarding to your ngrok endpoint. It works, but you’re now hosting and maintaining an extra piece of infrastructure (typically on something like Render or Vercel) just to route around a warning page.

Method 3: Upgrade or Switch Tools

The interstitial isn’t a permanent free-tier tax you have to engineer around — it’s genuinely tied to the plan. Here’s what ngrok’s pricing actually looks like as of mid-2026, straight from ngrok’s own pricing page:

Plan	Price	Data transfer	Interstitial page
Free	$0	1 GB/mo, 20k HTTP requests	Yes, on HTTP/S endpoints
Hobbyist	$8/mo billed annually ($10 billed monthly)	5 GB included, then metered	No
Pay-as-you-go	$20/mo base + usage	5 GB included, then $0.10/GB	No
Enterprise	Custom	Custom	No

The Free plan includes $5 of one-time included usage, up to 3 online endpoints, up to 1GB data transfer, and up to 20k HTTP/S requests, with the interstitial page on HTTP/S endpoints. The Hobbyist plan runs $8/month billed annually or $10 billed monthly, includes 5GB of data transfer, and removes the interstitial page on HTTP/S endpoints by default. So the fastest fix, if you’re otherwise happy with ngrok, is the $8–10/month Hobbyist tier — no header injection needed.

If you’d rather move off ngrok entirely, here’s an honest look at the main alternatives, corrected against each vendor’s current published pricing and feature pages.

Tunnelto — Actually Two Different Projects

This is where a lot of 2026 “ngrok alternative” content gets confused, so it’s worth being precise: tunnelto.dev and tunnelto.me are unrelated products that happen to share a name.

• tunnelto.dev is the original open-source Rust tunnel built by developer agrinman. The GitHub repository currently sits at 6.8k stars and 535 forks, MIT licensed, with its most recent client release (0.1.18) shipped in May 2021. The project’s own README still points to tunnelto.dev as the actively hosted version, run on fly.io — so it isn’t abandoned exactly, but the CLI hasn’t shipped new features in years, and it has no custom-domain or authentication support.
• tunnelto.me is a separate, actively maintained commercial service with no connection to the open-source project. Its own FAQ is explicit about this: tunnelto.me is a hosted, actively maintained tunneling service with custom domains on every plan and built-in endpoint authentication, while tunnelto.dev is a different open-source Rust project by agrinman whose last release shipped in 2021.

If a comparison piece claims “the hosted .me service is dominating the space” based on GitHub star growth, that’s conflating the two — the star surge belongs to the open-source tunnelto.dev repo, not the tunnelto.me commercial service.

What tunnelto.me actually offers, per its current pricing page:

The Free plan includes 1 tunnel on tunnelto.me, 1 GB bandwidth per month, unlimited 1-hour tunnels on 1 custom domain, a 100 req/min rate limit, and 5 Mbps speed, with no credit card required. The Hobbyist plan is $2/month and adds unlimited persistent tunnels (versus tunnels that expire after 1 hour on Free) plus password and bearer-token authentication. Plus, the “Most Popular” tier, is $10/month with 10 GB bandwidth and 3 custom domains, and Pro is $20/month with 20 GB bandwidth.

Two things worth flagging that the “no strings attached” framing usually skips:

1. Free tunnels expire after an hour. Free tunnels expire after 1 hour and have to be re-created, while Hobbyist tunnels are persistent and stay up across reboots and overnight breaks — not a dealbreaker for active dev sessions, but it does mean the free plan isn’t suitable for a webhook endpoint you want to leave running unattended.
2. Bandwidth is capped at 1 GB/month on both Free and Hobbyist — the same ceiling as ngrok’s free tier. You have to move to the $10/month Plus tier before bandwidth stops being a comparable constraint.

Nothing on tunnelto.me’s site claims an explicit “we will never show a warning page” promise — the interstitial simply doesn’t appear anywhere in its feature list, pricing page, or FAQ, which is a reasonable proxy for “it doesn’t have one,” but isn’t a documented guarantee the way ngrok’s interstitial removal is.

Installing tunnelto.me (this is the correct CLI for the hosted .me service — it differs from the older agrinman client):

# macOS / Linux
curl -sf https://app.tunnelto.me/install.sh | sh

# Windows (Scoop)
scoop bucket add tunnelto https://github.com/asabi/scoop-tunnelto
scoop install tunnelto

# Point a subdomain at a local port
tunnelto add api 8080

# Or bring your own domain
tunnelto add api.mycompany.com 8080

LocalXpose — Multi-Protocol, Paid Unlimited Bandwidth

LocalXpose’s free Starter plan includes 2 active HTTP/HTTPS tunnels with SSL/TLS encryption and unique subdomains, but carries time limits and an interstitial warning page — so it doesn’t solve the “free and no warning page” problem the way the headline claim in most comparisons implies.

The Pro plan is $8/month if billed annually ($96/year) and includes 10 tunnels, HTTP/HTTPS/TCP/TLS/UDP support, custom domains, wildcard tunnels, automatic certificates, ²⁴⁄₇ availability, and unlimited bandwidth subject to LocalXpose’s acceptable use policy. The UDP support is the genuine differentiator here — neither ngrok nor tunnelto.me tunnel UDP, which matters if you’re testing game servers, VoIP, or CoAP/DTLS-based IoT devices.

Tunnelmole — Fully Open Source, Self-Hostable

Tunnelmole is free and open source software: the client is MIT licensed and the service is AGPLv3. It uses the hosted service at tunnelmole.com by default, and can also be self-hosted, which is the strongest privacy story of the group if you don’t want your traffic passing through anyone’s managed infrastructure at all. It’s a native Node.js tool (16.10+), installs via npm install -g tunnelmole, and doesn’t show a splash screen on the hosted service.

Pinggy — No Client Install, SSH-Based

Pinggy’s pitch is that it needs nothing installed beyond a stock SSH client. The current command format is:

ssh -p 443 -R0:localhost:3000 free@a.pinggy.io

The -p 443 keeps the connection alive on networks that block port 22, and R0 tells the server to assign a port dynamically; Pinggy responds with a public HTTPS URL that routes to your local port.

The free tier is genuinely free-forever, but it comes with a real limitation the “free and unlimited” framing tends to leave out: tunnels expire after 60 minutes, and the URL changes on every restart, since persistent addresses require the paid Pro tier. Pro runs roughly $3/month billed monthly or about $2.37–$2.50/month billed annually, and adds persistent tunnels, custom domains, persistent TCP/UDP ports, and team management.

Cloudflare Tunnel — Two Very Different Modes

This is the biggest correction to make here: Cloudflare Tunnel does not strictly require you to own a domain. There are two distinct modes:

• Quick Tunnels (TryCloudflare): these let you experiment with Cloudflare Tunnel without adding a site to Cloudflare’s DNS — TryCloudflare generates a random subdomain on trycloudflare.com and proxies requests to your local server. No account creation, no configuration files, and no domain needed — one command (cloudflared tunnel --url http://localhost:8000) and you’re live. The tradeoff: Cloudflare doesn’t guarantee any SLA or uptime for these, since they’re explicitly a testing surface, and the URL is random and changes on every run — functionally similar to ngrok’s free tier, minus the interstitial.
• Named Tunnels: the persistent, production-grade version does require a Cloudflare account and a domain whose DNS you point at Cloudflare, since that’s how it issues a stable custom-domain endpoint with Zero Trust access controls.

So: for a quick, no-warning-page, no-domain-needed demo link, Quick Tunnels cover exactly the use case this article is about. For something you want to keep running long-term on your own domain, you’re into Named Tunnels and the domain requirement applies.

Migrating from ngrok to tunnelto.me: Step by Step

If you want a persistent, custom-domain tunnel without ngrok’s interstitial, here’s the actual current workflow.

1. Install the CLI

curl -sf https://app.tunnelto.me/install.sh | sh

2. Start your local server as usual — for example, a React dev server on port 3000:

npm run start

3. Create the tunnel. Instead of ngrok http 3000:

tunnelto add api 3000

Or bind a domain you already own:

tunnelto add api.yourdomain.com 3000

Remember: on the Free plan this tunnel expires after an hour, so for anything left running unattended — a webhook receiver, an OAuth callback — you’ll want the $2/month Hobbyist tier for persistence.

4. Point your webhook or test config at the resulting HTTPS URL. No interstitial, no header injection, no bypass logic required.

Conclusion

The interstitial page isn’t going away on ngrok’s free tier — it’s a deliberate anti-phishing measure, not a bug, and ngrok is upfront that its own documented bypasses (the skip-warning header, a custom User-Agent, or the $8/month Hobbyist plan) are the supported paths around it. Which fix makes sense depends on what’s breaking: header injection is enough for your own scripts and CI, a forward proxy handles webhooks you can’t modify, and switching to Tunnelmole, Pinggy, Cloudflare Quick Tunnels, or a paid tunnelto.me/LocalXpose plan solves it structurally if you’d rather not build around the warning page at all.

---

Changelog

Corrections

1. ngrok pricing structure — Replaced the vague “$8 to $10/month” framing with the exact current tier structure (Free $0, Hobbyist $8/mo annual or $10/mo monthly, Pay-as-you-go $20/mo + usage, Enterprise custom), and noted explicitly that the Hobbyist plan removes the interstitial by default. Source: ngrok Pricing page.
2. “Tunnelto is dominating the space” claim — This conflated two unrelated products. Clarified that tunnelto.dev (agrinman’s open-source Rust project, 6.8k GitHub stars, last client release May 2021) and tunnelto.me (a separate, actively maintained commercial service) are different products with no connection, per tunnelto.me’s own FAQ.
3. Tunnelto pricing — Corrected “just $2/month” to the full current tier breakdown: Free $0, Hobbyist $2/mo, Plus $10/mo (labeled “Most Popular” on their site), Pro $20/mo, Enterprise custom.
4. Tunnelto CLI syntax — The original draft’s migration walkthrough used tunnelto --port 3000 and tunnelto login, which is the older agrinman/tunnelto.dev client syntax, not tunnelto.me’s. Replaced with tunnelto.me’s actual install script and tunnelto add <domain> <port> command.
5. Cloudflare Tunnel domain requirement — The original draft stated Cloudflare Tunnel “strictly requires you to own and configure your own domain.” This is only true for Named Tunnels. Cloudflare’s Quick Tunnels (TryCloudflare) require no domain and no account at all, generating a random trycloudflare.com URL — functionally comparable to ngrok’s free tier, without the interstitial. Both modes are now described.
6. Pinggy SSH command — Updated to the current documented syntax (free@a.pinggy.io with explicit user prefix) per Pinggy’s own docs.

Additions

1. Added ngrok’s exact Free-plan limits (1GB/month, 20k requests, 3 online endpoints) sourced directly from ngrok’s documentation.
2. Added tunnelto.me’s free-tier 1-hour tunnel expiry and shared 1GB/month bandwidth cap (same ceiling as ngrok free) — both omitted from the original draft’s “no strings attached” framing.
3. Added Pinggy’s 60-minute free-tier timeout, which the original draft’s “free tier without sign-ups” framing didn’t mention.
4. Confirmed LocalXpose’s free Starter tier does carry an interstitial warning page and time limits, consistent with the original draft, via LocalXpose’s own current pricing page.
5. Added a note on Tunnelmole’s open-source licensing (MIT client / AGPLv3 server) and self-hosting option.

Note on sourcing: All pricing and feature figures above were checked directly against each vendor’s live pricing/docs pages as of early August 2026. Tunnel-tool pricing changes frequently — worth re-verifying before publishing if this sits in a queue for more than a few weeks.