# Ping from Many Places

Ping a host name or public IP address from our own server or from many places at once through Globalping, a free network of volunteer probe machines. Returns, for each place, its country, city, network and whether it is a data centre or a home connection, the address it reached, every reply time, min, average, max, jitter and packet loss, plus a summary (median, fastest, slowest, worst loss, whether a CDN answers from everywhere) and a verdict: up, partial, down or icmp-blocked (the host is up but drops ping; TCP works). Choose the places with a preset, or free text such as a country, city, AS7922 or aws-us-east-1. From REST and MCP at most 5 places run. The target is sent to Globalping.

**Not for:** Testing the caller's own connection speed, or scanning a network.

- Tool id: `ping`
- Category: network
- Execution: fanout
- MCP tool `ping` at https://lookupowl.com/mcp
- REST `GET https://lookupowl.com/api/v1/tools/ping` (or POST a JSON body)
- OpenAPI: https://lookupowl.com/api/openapi.json

## Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `target` | string | yes |  | A host name or a public IP address. A web address works too: the host is taken from it. min length 1, max length 253 |
| `mode` | "server" \| "global" | no | `"global"` | server: one check from our own server, no third party. global: from many places through Globalping, a free probe network (the target is sent to it). |
| `preset` | "worldwide" \| "europe" \| "north-america" \| "asia-pacific" \| "south-america-africa" | no | `"worldwide"` | Which part of the world to test from: worldwide, europe, north-america, asia-pacific or south-america-africa. Ignored when `from` is set. |
| `from` | string | no |  | Where to test from, as free text: a country, a city, a network such as AS7922 or Comcast, or a cloud region such as aws-us-east-1. Overrides `preset`. max length 100 |
| `places` | integer | no | `6` | How many places to test from, 1 to 10. From REST, MCP and the web form without JavaScript at most 5 run. min 1, max 10 |
| `eyeball` | boolean | no | `false` | Only home and office networks, not data centres. There are fewer of these, so fewer places may answer. |
| `packets` | integer | no | `4` | Packets to send from each place, 1 to 10. min 1, max 10 |
| `protocol` | "icmp" \| "tcp" | no | `"icmp"` | icmp: a normal ping. tcp: time a TCP connection instead, which works when a firewall blocks ping (it measures connection time, not ping). |
| `port` | integer | no | `443` | The port for tcp. Ignored for icmp. min 1, max 65535 |
| `family` | "4" \| "6" \| "auto" | no | `"auto"` | auto: whatever the name resolves to. 4 or 6: that family only. |
| `id` | string | no |  | A Globalping measurement id from a permalink: show that saved result instead of running a new one. Set by the page, not by hand. max length 40 |
| `compareId` | string | no |  | The Globalping id of the IPv4 run to put next to the IPv6 saved result in `id`. Set by the page, not by hand. max length 40 |

## Output

Results are wrapped in an envelope: `tool`, `version`, `requestId`, `data`, `summary`, `meta` (cache status, timing), `permalink`. `data` has these fields:

| Field | Type | Description |
|---|---|---|
| `target` | string |  |
| `mode` | "server" \| "global" |  |
| `protocol` | "icmp" \| "tcp" | What was measured. From our own server this is always tcp: a web server cannot send ping packets, so we time a TCP connection. |
| `port` | integer | The TCP port, when protocol is tcp. min -9007199254740991, max 9007199254740991 |
| `family` | "4" \| "6" \| "auto" |  |
| `packets` | integer | min -9007199254740991, max 9007199254740991 |
| `dns` | object |  |
| `places` | object[] |  |
| `summary` | object |  |
| `tcpFallback` | object | When ping got no answer anywhere, we tried a TCP connection to port 443 from the same places. |
| `v4vsV6` | any[] | IPv4 and IPv6 side by side, per place. Only for family 6. |
| `notes` | string[] | Plain sentences about how this run was done (our server, place cap, a literal IPv6 address). max 6 items |
| `incomplete` | boolean | The wait ran out before every place was final; this is what we had. |
| `expired` | boolean | The saved measurement is gone (Globalping keeps results for about six months). Run it again. |
| `measurementId` | string | The Globalping measurement id (the permalink). Absent for a check from our own server. |

## Examples

### example.com from five places

```json
{"target":"example.com","mode":"global","preset":"worldwide","places":5,"eyeball":false,"packets":4,"protocol":"icmp","port":443,"family":"auto"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/ping?eyeball=false&family=auto&mode=global&packets=4&places=5&port=443&preset=worldwide&protocol=icmp&target=example.com'
```

Web page: https://lookupowl.com/global-ping?q=example.com&places=5

### example.com from our server

```json
{"target":"example.com","mode":"server","preset":"worldwide","places":1,"eyeball":false,"packets":4,"protocol":"tcp","port":443,"family":"auto"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/ping?eyeball=false&family=auto&mode=server&packets=4&places=1&port=443&preset=worldwide&protocol=tcp&target=example.com'
```

Web page: https://lookupowl.com/ping?q=example.com&places=1&protocol=tcp

### The 1.1.1.1 resolver from our server

```json
{"target":"1.1.1.1","mode":"server","preset":"worldwide","places":1,"eyeball":false,"packets":4,"protocol":"tcp","port":443,"family":"auto"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/ping?eyeball=false&family=auto&mode=server&packets=4&places=1&port=443&preset=worldwide&protocol=tcp&target=1.1.1.1'
```

Web page: https://lookupowl.com/ping?q=1.1.1.1&places=1&protocol=tcp

### An IPv6 address from our server

```json
{"target":"2606:4700:4700::1111","mode":"server","preset":"worldwide","places":1,"eyeball":false,"packets":4,"protocol":"tcp","port":443,"family":"auto"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/ping?eyeball=false&family=auto&mode=server&packets=4&places=1&port=443&preset=worldwide&protocol=tcp&target=2606%3A4700%3A4700%3A%3A1111'
```

Web page: https://lookupowl.com/ping?q=2606%3A4700%3A4700%3A%3A1111&places=1&protocol=tcp

### github.com over TCP on port 443

```json
{"target":"github.com","mode":"server","preset":"worldwide","places":1,"eyeball":false,"packets":4,"protocol":"tcp","port":443,"family":"auto"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/ping?eyeball=false&family=auto&mode=server&packets=4&places=1&port=443&preset=worldwide&protocol=tcp&target=github.com'
```

Web page: https://lookupowl.com/ping?q=github.com&places=1&protocol=tcp

### Cloudflare over IPv6 and IPv4

```json
{"target":"cloudflare.com","mode":"server","preset":"worldwide","places":1,"eyeball":false,"packets":4,"protocol":"tcp","port":443,"family":"6"}
```

```bash
curl 'https://lookupowl.com/api/v1/tools/ping?eyeball=false&family=6&mode=server&packets=4&places=1&port=443&preset=worldwide&protocol=tcp&target=cloudflare.com'
```

Web page: https://lookupowl.com/ping-ipv6?q=cloudflare.com&places=1&protocol=tcp

## Web pages

- https://lookupowl.com/ping
- https://lookupowl.com/ping-ipv6
- https://lookupowl.com/global-ping

## Limits and caching

- Cost: from 1 unit up, depending on the input (a registry lookup counts every upstream request); 1 unit for a cached result. Budgets are per network and published in the `RateLimit` response headers.
- Cache: results are kept for 30 s.
- Timeout: 40 s.

## Related tools

- [Traceroute and MTR](https://lookupowl.com/tools/traceroute.md): Trace the path to a host from our server or other places, with the network behind each hop and a plain verdict.
- [Is It Down? Check a Website from Many Places](https://lookupowl.com/tools/http-check-global.md): Check a website from probes in many places: name lookup, connection, certificate and web server, with a plain verdict.
- [Port Checker: Is a Port Open from the Internet?](https://lookupowl.com/tools/port-check.md): Check whether a TCP port on your connection is open from the internet (the port-forwarding test), or a well-known port on a public server.
- [DNS Lookup](https://lookupowl.com/tools/dns-lookup.md): Look up A, AAAA, MX, NS, TXT, CNAME, SOA, CAA, DS and DNSKEY records from a public resolver or the authoritative nameserver.
- [IP Location Lookup](https://lookupowl.com/tools/ip-location.md): Where an IP address is: city, region, country and the network that runs it, from DB-IP, with an honest accuracy note.

## Guide: Ping from many places

Enter a host name or an IP address to see whether it answers, how fast, and whether that changes between countries.

### What this ping test does

A ping sends a few small packets to a host and times how long each reply takes. It answers three questions in order: does the host answer at all, how fast and how steady is it, and is that the same everywhere. This page sends the packets from places you choose and puts the answers side by side, with a map, a bar for each place and the numbers underneath.

It tests a server you name, from other places. It is not a test of your own connection. Want to test your own connection? Try the speed and latency test.

- **Reply time.** The round trip of each packet in milliseconds, with the fastest, the average and the slowest.
- **Jitter.** How much the time changes from one packet to the next. A steady line is good for calls and games.
- **Loss.** The share of packets that never came back.
- **Where it answered from.** The city, the network and whether the probe sits in a data centre or on a home connection.

### How to run a ping test

1. **Enter a host or an address**: A domain name such as `example.com` or a public IP address such as `1.1.1.1`. A web address works too: only the host name is used.
2. **Choose where to run it**: "From our server" is one place, and nothing is sent to anyone else. "From many places" asks a network of volunteer probes to ping from a spread of countries. You can pick an area, or type a country, a city, a network such as `AS7922` or a cloud region such as `aws-us-east-1`.
3. **Read the answer**: The headline says whether the host answers everywhere. Open a row to see every packet, the address that place reached and the probe it came from.

### How to read the times

We group reply times into four bands, always with a word and a shape as well as a colour: fast is under 50 ms, good is 50 to 150, slow is 150 to 300 and very slow is over 300. These are rules of thumb. Distance sets the floor: light in fibre takes about 1 ms per 100 km each way, so a server in Frankfurt cannot answer a probe in Sydney in 10 ms, whatever its hardware.

| What you see | What it usually means |
|---|---|
| One place far slower than the rest | The nearest server is a long way from that place, or the path there is poor. Only that row is flagged. |
| A few lost packets at one place | Often harmless. One reply in four missing once is not a problem by itself. |
| Steady loss at several places | Congestion or a busy server. Try again in a few minutes and compare. |
| No reply anywhere | The host may be off, may point at the wrong address, or may ignore ping on purpose. |

### From our server, or from many places

A web server cannot send real ping packets, because that needs privileges ours does not have. So from our own server we time a TCP connection to a web port instead, and the result says so. It measures connection time, which is close to a ping but not the same thing. For a true ping from several countries, choose many places.

Many places runs through [Globalping](https://globalping.io), a free network of volunteer probe machines. The first time, the page asks before anything is sent. Your browser then asks Globalping to run the check, and Globalping receives the target and your IP address. Without JavaScript, our server asks Globalping for up to 5 places on your behalf instead, and it receives the target and our server's address.

### CDNs, blocked pings and what to try next

> **Low times everywhere can mean a CDN** Many sites sit behind a CDN, which answers from a server close to every probe. Times of 1 to 13 ms from six continents describe the CDN, not the website's own server. We say so when the address belongs to one.

Some hosts drop ping on purpose and still serve websites. When nothing answers to ping we try a TCP connection to port 443 from the same places. If that works, the verdict is "up, but does not answer ping". If it does not, the page lists what to check next, and the [traceroute](https://lookupowl.com/traceroute) shows where the path stops, while the [port checker](https://lookupowl.com/port-checker) tests a single port.

### Frequently asked questions

**Is this the same as testing my own internet speed?**

No. This tool pings a server you name, from places around the world. To test your own connection, use a speed and latency test.

**Why do the places answer so fast?**

Many sites sit behind a CDN, which answers from a server close to every probe. Low times everywhere then describe the CDN, not the website's own server. The page adds a note when it sees this.

**What does "From our server" measure?**

A TCP connection to port 443, or another web port you pick, timed from our server. A web server cannot send ICMP ping packets, so we do not pretend to. The result is labelled TCP.

**Why did one place fail to run?**

The probes are volunteer machines, and one can go offline or time out before it starts. We list it as "didn't run" with the reason and leave it out of the verdict, because it says nothing about the host.

**What is a good ping time?**

Under 50 ms is fast and under 150 ms is good for most things. The distance to the server sets the lowest possible time, so compare places that are far apart with that in mind.

**Why does a host answer in a browser but not to ping?**

Many firewalls drop ICMP on purpose. When ping gets no answer anywhere, we try TCP port 443 from the same places and tell you if the host is up but ignores ping.

**Can I use this from a script or an AI assistant?**

Yes. The same check is in the REST API and the MCP server as the `ping` tool. Those run up to 5 places through our server and return every time, the loss and a verdict.