I wanted to know how fast each cloud region is from my home connection, so I built a tool for it
When I pick a region for a new server, I used to search for a cloud latency map and go with whatever looked green. At some point it clicked that every one of those maps, and every provider's looking glass, runs its tests from a datacenter. Datacenters buy good transit, so the numbers look great. My home line is one ISP with one set of international links, and those get crowded every evening. None of that shows up on a map measured from somewhere else.
The question I actually had was simple: from my connection, at this time of day, which region is closest?
So I built Me2Cloud: m2c.1ms.dog
You open the page and press Start. The requests go from your browser straight to each provider. It covers 361 regions across 17 providers: AWS, Azure, Google Cloud, Oracle, IBM Cloud, DigitalOcean, Linode, Vultr, Hetzner, OVHcloud and Scaleway, plus Alibaba Cloud, Tencent Cloud, Huawei Cloud, Volcengine, Baidu AI Cloud and Naver Cloud.

Today at noon I ran 6 of them from home in Beijing, 172 regions in about three minutes on the quick setting. AWS Beijing came in at 7.7 ms and Alibaba Cloud Beijing at 8.2 ms. Azure's best was Seoul at 83 ms, Google Cloud's was Los Angeles at 175 ms, and Hetzner Singapore was 500 ms. Those are the numbers that decide where I'd put a server, and you can't get them from a test that starts in Frankfurt.
Results are grouped into five tiers by median latency (GOATed, Top tier, Solid, NPC, Cooked). If you tell it what the server is for (gaming, video calls, SSH or a website), it applies the matching latency and jitter limits and suggests three regions.
A few decisions took more thought than the rest.
Why HTTPS requests instead of ping?
Partly because a browser can't send ICMP. But I wouldn't want ping anyway: websites, APIs and anything tunneled over 443 run on TCP, and plenty of ISPs queue or throttle ICMP separately. Ping can look fine while pages crawl.

The cost of HTTPS is a little server time on every request. I measured it per provider: roughly 0–5 ms on AWS, about 8 ms on Alibaba Cloud, about 20 ms on Huawei Cloud's object storage. Past 100 ms it doesn't matter; for regions very close to you, expect slightly higher numbers than ping. The first request pays for the TLS handshake and isn't counted. Every sample after that reuses the same connection, so it's one round trip.
What if I usually run a proxy?
Then you'll probably see Singapore, Tokyo and Frankfurt all within a few milliseconds of each other. That's the latency to your proxy node, not to the clouds. Before testing, the page checks a few things: whether your exit IP belongs to a datacenter, whether your timezone matches the exit country, whether WebRTC and HTTPS leave from the same address. If something looks off, it says so and gives you direct-connection rules for Clash/Mihomo, Surge, Shadowrocket, Quantumult X, Loon, sing-box, Xray or SwitchyOmega.

The rules went through a few versions. Early on some tools got suffix matches like amazonaws.com, which was easy but also sent every S3 download of yours direct, and in some countries direct is the slow path. Now the rules list only the 413 hostnames the test actually uses. No wildcards.
Won't hundreds of regions at once get you blocked?
If the requests come too fast, a provider's WAF or rate limit steps in and the numbers stop meaning anything. So each hostname gets one request at a time, at least 250 ms apart, 21 at most per run, and a host is skipped after three failures in a row. That's less traffic than loading an average web page.
Where does my data go?
Nowhere. There's no backend and no account, and results stay in your browser. Every request shows up in DevTools, and there's a request log on the page too.

Sharing doesn't touch a server either. The share link packs the results into the URL itself, and the share image, like this one from the run above, is drawn on a canvas in your browser.
Open source, and easy to host yourself
MIT licensed: github.com/yt1988/me2cloud
It's a static site, and the built pages are already in the repo. On Cloudflare Workers static assets it's free and unmetered:
git clone https://github.com/yt1988/me2cloud && cd me2cloud
npx wrangler deploy
You don't need to deploy anything to test your own server, though. Add it as a custom endpoint on the page and it shows up in the same chart as the big providers.
What it won't tell you
It measures one place, yours, not your users'. Ask a few of them to run it too. It tests each provider's public API or storage endpoint rather than the VM you'd rent, so premium network tiers can behave differently. It doesn't test bandwidth or UDP. And run it again between 8 and 11pm; peak hour is the result that counts.
I built it to pick regions for my own projects. If there's a provider or region you'd like added, or an endpoint that doesn't respond from where you are, open an issue or leave a comment.
Comments
very nice
very nice
Bump, great deal
great job
really cool tool man. love that you actually thought of proxy users and generated exact hostname direct rules for sing-box/mihomo without wildcarding amazonaws, having to toggle my tun mode off every time i want to test raw latency is always a pain
since this is les, any plans to add some more budget/indie providers alongside hetzner and ovh in the future (like netcup, leaseweb, or buyvm)? although the custom endpoint feature pretty much covers that already tbh. great work!
TierHive - Hourly VPS - NAT Native - /24 per customer - DE, UK, SG, CA x2, USA x5, FR x3, AU, PL, NL, JP, BR, ZA
FREE tokens on sign up, try before you buy. | Static Hosting Free for life: https://tierhive.com/static-hosting/
good, I would like to ask how these nodes are obtained.
These endpoints are mostly provided by the official test sites to reflect real-world latency as accurately as possible.
How do you know I am using a proxy?
https://egress.1ms.dog/
https://who.1ms.dog/
You can refer to the results from these two tools. Most of the time, they assess locations using several factors, including time zone, language, and IP region.
Interesting project, thanks for sharing it.
One caveat about the Hetzner numbers, though. In my run, Nuremberg came out as the worst region of all at a ~2 s median, which definitely doesn't reflect reality.
(this on a 5G connection in Northern Italy + Wireguard VPN towards MIX-IT)
From the same connection, ICMP to fsn1-speed.hetzner.com averages ~58 ms, and a warm HTTPS request with curl gets the first byte in 50-80 ms, on par with OVH Roubaix.
I've then read your
build-registry.mjsand foundThe *-speed.hetzner.com hosts drop any request that carries a query string. The TLS handshake completes, then the server closes the connection without sending an HTTP response (curl reports "unexpected eof while reading"). Since every probe gets a ?_clp=... cache-buster, fetch() never gets an answer. Your curl test presumably used the bare URL, which works. Without the query string, a no-cors GET works fine from the browser too.
The
fallback avoids the error but, as the same note says, every sample then pays for TCP + TLS: in Chromium and Firefox I get ~200 ms per sample, against ~60 ms for OVH on a reused connection. So the Hetzner figures aren't comparable with the rest, yet they're ranked and colour-coded on the same scale, which makes Hetzner look like the worst provider when it may well be among the best. The ~2 s I saw goes beyond even that; I couldn't reproduce it, so something else may be going on there.
Two possible pathways to correct this: skip the cache-buster for Hetzner, as you already do for the CDNs (cache: "no-store" should be enough to keep the browser cache out of it); or, until then, flag the Hetzner results as not comparable instead of ranking them at the bottom.
@mfs Thank you for this. You were right, and following it up turned up a second cause behind the first. Both are fixed and live.
Why it happened
The query string. The
*-speed.hetzner.comservers close the connection right after the TLS handshake, without any response, on any request whose URL has a query string. Every probe added a?_clp=…cache-buster, sofetch()never got an answer. The<img>fallback only "worked" because an image firesonerrorwhen the connection drops, so each sample was a full handshake that ended in a dropped connection. (These servers also drop any request carrying aRefererheader. Our probes already send none, but it matters if you test by hand from a devtools console.)Opaque Response Blocking. Dropping the query string, as you suggested, was necessary but not enough in Chrome. The only URL these servers answer is
/, and it returns HTML. Chrome blocks HTML, JSON and XML responses tono-corsrequests before they reach the page (ORB). It cancels the request and throws the connection away, so every sample still paid a new TCP + TLS handshake. curl reused the connection fine, which is why it looked like a browser-only mystery.What we changed
GETto the bare URL with no cache-buster (cache: "no-store"keeps the browser cache out), sent in CORS mode. Hetzner sends noAccess-Control-Allow-Origin, so the browser rejects the request, but only after the whole response has arrived. The connection is kept, and that rejection is timed as the answer. To make sure a dropped connection isn't mistaken for one, the warm-up first sends a normalno-corsrequest, which only succeeds if the server really answers. (eef448d, 59bcaf7)Every other provider checked for the same two problems:
no-corsagainst CORS mode on the same region: equal within noise for all of them except Huawei Cloud.The details panel now warns about a new connection on every sample based on what was measured: it shows when even the fastest sample is about as slow as the warm-up request. Previously it was tied to the
<img>method. (40f1f95)Test results
On the server side, from a VPS in Germany with curl (median time to first byte):
?_clp=…or aRefererOn a reused connection the time matches ping. A new connection per request costs about 3× ping, which is what the old method was measuring.
In Chrome on the live site, from my home line in Beijing, measured the same evening (median of 10 samples). The reference column is curl from the same machine on a reused connection.
For comparison, OVH Roubaix was 137 ms in the same run, so Hetzner is now ranked on the same scale as everyone else. My evening route still has a lot of jitter (±80 ms on nbg1), which the page flags separately, but the samples no longer pay for a handshake each time.
I couldn't reproduce the ~2 s Nuremberg median either. My guess is that a full handshake on every sample, plus the latency and jitter of 5G and WireGuard, compounded into that. If you run it again, I'd be glad to hear whether Hetzner now looks right from your side.
Thanks again for reading the source and writing it up so clearly. It led to fixes for two providers, not one.
Interesting idea. Testing from your own connection makes the comparison much more useful than relying on a generic latency map. Thanks for explaining the limitations too.
First post! I like this. Pretty smart.
This is the right way round. Datacenter to datacenter numbers never matched what I see from home, especially in the evening when the local ISP gets congested. A region that looks great on paper can be unusable at 9pm. Nice work putting it in the browser, that is where the pain actually is.
Break it, learn it, fix it.
Wow, impressive work!
Hi, i am genuinely impressed. This is a really great app. How long have you been working on this? I'm from the Caribbean, Trinidad and Tobago and this may have helped in my choosing the best host for my site.
ProxyForge - free Nginx & Apache config generators, tested on real servers
proxyforge.tech