Ngrok vs Cloudflare Tunnel vs LocalCan vs Pinggy vs LocalXpose: Speed Test Results 2025

When you're developing SaaS applications, APIs or web apps locally, you need a way to expose your localhost to the internet. Maybe you're showing a demo to a client, testing with team members, or working with OAuth integrations.

But here's the thing - not all tunneling services are created equal. Some are lightning fast, while others will make you want to throw your laptop out the window.

I tested the top 6 tunneling services to see which one actually delivers the best speed. The results might surprise you.

What Are Tunneling Services?

Think of tunneling services as a bridge between your local computer and the internet. They create a public URL that points directly to your localhost server.

Instead of explaining complex port forwarding to your client, you just send them a link like https://abc123.tunnel-service.com and boom - they can see your work in progress.

Here are the most popular options:

• Ngrok - The old reliable choice
• Cloudflare Tunnel - Free option from Cloudflare
• LocalCan - macOS-focused tool with GUI and .local domains
• LocalXpose - Another ngrok alternative
• Pinggy - Simple tunneling service

Why Speed Matters for Development

Slow tunnels aren't just annoying - they can actually hurt your development process.

When you're building SaaS applications, you're constantly sharing work-in-progress with clients, team members, and stakeholders. Slow file uploads, laggy API responses, and sluggish page loads make your app feel broken even when it's not.

Nothing kills the vibe like a laggy connection when you're demoing your latest features to potential customers or investors.

How I Tested These Services

I wanted to make this test as real-world as possible. Here's exactly what I did:

The Setup

• Created a simple Node.js server that serves a 100 MB file
• Ran each tunneling service pointing to this local server
• Used curl to download the file and measure speed
• Tested in the morning, afternoon, and evening, then averaged the results
• All services used EU edge servers, the same region as my test server
• My internet connection's max upload speed is 60 Mbps

The Test Server Code

This server simulate a real-world file download scenario by serving a 100MB file. It uses the Fastify framework to handle HTTP requests and streams the file content dynamically to the client, allowing us to measure the download speed of different tunneling services.

import Fastify from 'fastify'
const fastify = Fastify({ trustProxy: true })

fastify.get('/download', async (request, reply) => {
  let byteCount = 100 * 1024 * 1024 // 100MB

  const { Readable } = await import('node:stream')

  let producedBytes = 0
  const stream = new Readable({
    read(size) {
      // Push data until byteCount is reached
      while (producedBytes < byteCount) {
        const remainingBytes = byteCount - producedBytes
        const chunkSize = Math.min(size, remainingBytes)
        const buffer = Buffer.alloc(chunkSize, 'a')

        if (!this.push(buffer)) {
          // If push returns false, stop pushing until _read is called again
          producedBytes += chunkSize
          return
        }
        producedBytes += chunkSize
      }
      // If all bytes are produced, push null to signal EOF
      if (producedBytes >= byteCount) {
        this.push(null)
      }
    },
  })

  reply.header('Content-Disposition', `attachment; filename="test-download-${byteCount}.dat"`)

  reply.header('Content-Length', byteCount)
  return reply.type('text/plain').send(stream)
})

// Start the server
fastify.listen({ port: 3000, host: '127.0.0.1' }, (err) => {
  if (err) throw err
})

The Speed Test Command

This command uses curl to download a 100MB file from a specified URL, while suppressing the output. It measures the total time taken, the size of the download, and the download speed. The awk script then formats these results to display the download statistics in both MB/sec and Mbps.

curl -k -o /dev/null "https://example.com/download" -s --write-out "%{time_total}\n%{size_download}\n%{speed_download}\n" | awk '
NR==1 {tt=$0}
NR==2 {sd=$0}
NR==3 {sb=$0}
END {
  printf "Download stats:\nTime total:   %s seconds\nDownload:     %s bytes\nSpeed:        %.2f MB/sec\nSpeed:        %.2f Mbps\n", tt, sd, (sb / 1000000), (sb * 8 / 1000000);
}'

Example output:

Download stats:
Time total:   30.215676 seconds
Download:     104857600 bytes
Speed:        3.47 MB/sec
Speed:        27.76 Mbps

Simple, repeatable, and focused on real transfer speeds.

Speed Test Results: The Rankings

Here are the results from fastest to slowest:

1. LocalCan Beta - 51.35 Mbps ⚡

Download time: 16.3 seconds
Speed: 6.42 MB/sec (51.35 Mbps)

The clear winner. LocalCan's new tunnels (now in beta) absolutely crushed the competition. This is impressive for a relatively new player in the tunneling space.

2. Cloudflare Tunnel - 46.30 Mbps 🥈

Download time: 18.1 seconds
Speed: 5.79 MB/sec (46.30 Mbps)

Cloudflare's massive global network shows its strength here. Plus, it's free, which makes this performance even more impressive.

3. LocalCan (Stable) - 27.76 Mbps 🥉

Download time: 30.2 seconds
Speed: 3.47 MB/sec (27.76 Mbps)

The stable version of LocalCan is notably slower than the beta, but still respectable. Shows the team is actively improving performance.

4. LocalXpose - 9.25 Mbps

Download time: 90.7 seconds
Speed: 1.16 MB/sec (9.25 Mbps)

A significant drop in performance here. Nearly 3x slower than LocalCan stable.

5. Ngrok - 8.81 Mbps

Download time: 95.2 seconds
Speed: 1.10 MB/sec (8.81 Mbps)

The industry standard, but clearly not the speed standard. Ngrok's popularity doesn't translate to performance leadership.

6. Pinggy - 6.69 Mbps

Download time: 125.5 seconds
Speed: 0.84 MB/sec (6.69 Mbps)

The slowest of the bunch. Over 2 minutes to download 100MB is pretty painful for development work.

What These Results Mean for Developers

The speed differences are huge. LocalCan Beta is 7.6x faster than Pinggy. That's not a small optimization - that's a completely different experience.

Here's what this means in practical terms:

For SaaS demos: Fast file uploads, quick API responses, and snappy page loads make your app feel professional and production-ready.

For client presentations: Nobody wants to wait 2 minutes for a dashboard to load during a sales demo.

For team collaboration: Faster tunnels mean smoother development workflows when sharing progress with remote team members.

I learned this the hard way while demoing a Next.js dashboard to a potential client. Next.js development builds typically serve ~2MB JavaScript chunks, and with my old tunnel running at under 1 MB/sec, there was this awkward 3-4 second pause right in the middle of page loads.

The page would start loading, show the header and navigation, then just... freeze. The client actually asked if the app was broken. After switching to a faster tunnel, the same demo felt completely different - smooth, professional, and responsive. That's when I realized tunnel speed isn't just a technical detail, it's part of your product's first impression.

Beyond Speed: Other Factors to Consider

Speed isn't everything (though it's pretty important). Here are other factors that might influence your choice:

Developer Experience (DX)

Most tunneling services operate through command-line interfaces (CLI), requiring users to download binaries and manage configurations via terminal commands. This includes remembering specific command flags and syntax for different operations.

LocalCan differentiates itself by providing a graphical user interface (GUI) for tunnel management, while still maintaining CLI capabilities. The GUI approach can simplify the learning curve for developers new to tunneling services.

Pro tip: You can actually use LocalCan's traffic inspection GUI with free Cloudflare tunnels. This gives you the speed of Cloudflare's network plus LocalCan's excellent request/response debugging interface - best of both worlds!

Pricing

• Cloudflare Tunnel: Free with ephemeral URLs
• LocalCan: $67-97 one-time, Teams at $15/seat/month
• Ngrok: Free tier, paid plans from $20/month for commercial use
• LocalXpose: Free tier, paid from $10/month
• Pinggy: Free tier, paid from $3/month

My Recommendations

Based on these speed tests, here's what I'd recommend:

For macOS developers: LocalCan Beta is the clear winner if you can handle beta software. The speed advantage is massive.

For budget-conscious developers: Cloudflare Tunnel offers excellent speed for free. Hard to beat that value.

For enterprise teams: LocalCan Teams provides great speed with professional features at $15/seat/month.

For maximum compatibility: Ngrok still has the most integrations, even if speed isn't its strong suit.

The Bottom Line

Speed matters more than you might think for tunneling services. The difference between the fastest (LocalCan Beta) and slowest (Pinggy) is dramatic enough to impact your daily development workflow.

If you're currently using a slow tunnel and wondering why your demos feel sluggish or your webhooks seem unreliable, the tunnel itself might be the culprit.

Here's a real example from my own experience: I was working on a React app with hot module replacement (HMR) enabled. With my previous tunnel running at ~2 MB/sec, every code change would take 3-5 seconds to reflect in the browser when sharing with my remote team. This made pair programming sessions frustrating - we'd make a change, wait, then often forget what we were testing by the time it loaded. After switching to faster privider, the same HMR updates now appear almost instantly - usually under 1 second. This transformed our remote collaboration sessions. We could iterate quickly, test ideas in real-time, and maintain our flow state instead of constantly waiting for updates to propagate.

Frequently Asked Questions

Q: Are these results consistent across different regions? A: This test used EU servers throughout. Results may vary in other regions, but the relative rankings should be similar.

Q: Does file size affect the rankings?
A: Larger files would likely show even bigger differences between fast and slow services. This 100MB test is pretty representative.

Q: What about latency vs throughput? A: This test focused on throughput (download speed). Latency tests would be valuable for real-time applications.

Q: Should I switch from ngrok based on these results? A: If speed is your main concern, yes. But consider your specific needs, integrations, and budget too.

Want to test LocalCan's speed yourself? Download the free trial and see the difference fast tunneling makes for your development workflow.