# ip-api.com

> Find out where an IP address is and who runs it, from ip-api.com's free geolocation service. Locate one address, a domain name, a list of addresses, or the address this workflow itself calls out from. Check whether a visitor is in a country you serve, whether they are behind a VPN or calling from a data centre, what time it is where they are, and how far away they are. No account or API key required.

App · Utilities · 9 actions. Web page: https://docs.lodol.com/docs/integrations/ip-api

## Actions

### Check an IP address for proxy, VPN or hosting

Report what kind of connection an address is on: a proxy, VPN or Tor exit node, a data centre, or a mobile network. Flags the first two together, which is the usual signal that a sign-up or a form submission is not coming from where it claims to be. Being on a phone network is reported but never flagged.

**Inputs**

- IP address or domain (`ip_address`, text, required): The IPv4 address, IPv6 address or domain name to look up. A domain is resolved by ip-api and the address it resolves to is what gets located. A whole URL is accepted too: only its host is used.

**Outputs**

- `as_name` (text): The AS's short registry name, e.g. 'VIDEOTRON'. Empty for address blocks not announced in BGP.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `flagged` (true/false): True when the address is a proxy or VPN, or sits in a data centre.
- `flags` (list): Which of those applied: 'proxy', 'hosting', or both.
- `hosting` (true/false): True for an address in a data centre or hosting provider, which is what a server or a bot usually calls from. Null when ip-api reported nothing.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `isp` (text): The internet provider serving the address.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `mobile` (true/false): True for a cellular connection. Null when ip-api reported nothing, which is not the same as false.
- `organization` (text): The organization the address is registered to, which is often the business behind it rather than the provider.
- `proxy` (true/false): True for a proxy, a VPN or a Tor exit node. Null when ip-api reported nothing, which is not the same as false.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `summary` (text): The same finding in a sentence.

**Example output**

```json
{
  "as_name": "VIDEOTRON",
  "country": "Canada",
  "country_code": "CA",
  "flagged": false,
  "flags": [],
  "hosting": false,
  "ip": "24.48.0.1",
  "isp": "Le Groupe Videotron Ltee",
  "location_label": "Montreal, Quebec, Canada",
  "mobile": false,
  "organization": "Videotron Ltee",
  "proxy": false,
  "query": "24.48.0.1",
  "summary": "This address looks like an ordinary consumer connection."
}
```

### Check an IP address's country

Answer whether an address is in one of the countries you name - the check behind sending someone to the right regional site, gating a feature by market, or flagging a sign-up from outside the countries you sell in. Answers with a plain true or false to branch on, plus where the address actually is.

**Inputs**

- IP address or domain (`ip_address`, text, required): The IPv4 address, IPv6 address or domain name to look up. A domain is resolved by ip-api and the address it resolves to is what gets located. A whole URL is accepted too: only its host is used.
- Countries (`countries`, list, required): The countries to test the address against. Pick from the list, or pass country names or two-letter codes from an earlier step: either is matched. One or more of: `AF` (Afghanistan), `AL` (Albania), `DZ` (Algeria), `AD` (Andorra), `AO` (Angola), `AI` (Anguilla), `AQ` (Antarctica), `AG` (Antigua & Barbuda), `AR` (Argentina), `AM` (Armenia), and 239 more.

**Outputs**

- `city` (text): The city, e.g. 'Montreal'.
- `continent` (text): The continent's name, e.g. 'North America'.
- `continent_code` (text): The continent's two-letter code, e.g. 'NA'.
- `countries` (list): The countries that were tested against.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `matched` (true/false): True when the address is in one of the countries named.
- `matched_country` (text): Which of them it matched, written the way it was given. Empty when none matched.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `region` (text): The region or state's name, e.g. 'Quebec'.

**Example output**

```json
{
  "city": "Montreal",
  "continent": "North America",
  "continent_code": "NA",
  "countries": [
    "CA",
    "US"
  ],
  "country": "Canada",
  "country_code": "CA",
  "ip": "24.48.0.1",
  "location_label": "Montreal, Quebec, Canada",
  "matched": true,
  "matched_country": "CA",
  "query": "24.48.0.1",
  "region": "Quebec"
}
```

### Check whether an IP address can be located

Answer whether an address can be located at all, and say why not when it cannot: a typo, a private address from inside a local network, or a reserved one such as a loopback. It answers no rather than failing, so it is what to branch on before spending a step on an address someone typed in.

**Inputs**

- IP address or domain (`ip_address`, text, required): The IPv4 address, IPv6 address or domain name to look up. A domain is resolved by ip-api and the address it resolves to is what gets located. A whole URL is accepted too: only its host is used.

**Outputs**

- `city` (text): The city, e.g. 'Montreal'.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `explanation` (text): The same reason written out, ready to show someone who typed the address in. Empty when it was located.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `kind` (text): What was asked about: 'ipv4', 'ipv6' or 'domain'.
- `located` (true/false): Whether ip-api could locate the address at all.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `reason` (text): Why it could not be located, in ip-api's own words: 'invalid query', 'private range' or 'reserved range'. Empty when it was located.

**Example output**

```json
{
  "city": "",
  "country": "",
  "country_code": "",
  "explanation": "That is a private address (10.x.x.x, 172.16-31.x.x, 192.168.x.x or fc00::/7). It only exists inside a local network, so it has no public location. Public traffic arrives from the network's own public address instead.",
  "ip": "",
  "kind": "ipv4",
  "located": false,
  "location_label": "",
  "query": "192.168.1.1",
  "reason": "private range"
}
```

### Get an IP address's network operator

Get who runs an address: the internet provider, the organization it is registered to, and its autonomous system, split into the number and the name so either can be matched on. Ask for reverse DNS as well to see the host name it points back to, which is how a crawler proves it is who it says.

**Inputs**

- IP address or domain (`ip_address`, text, required): The IPv4 address, IPv6 address or domain name to look up. A domain is resolved by ip-api and the address it resolves to is what gets located. A whole URL is accepted too: only its host is used.
- Look up reverse DNS (`include_reverse_dns`, true/false): Also return the host name the address points back to, e.g. 'wi-in-f94.1e100.net'. Off by default because ip-api warns that this lookup can make the request take noticeably longer. Default: `false`.

**Outputs**

- `as_name` (text): The AS's short registry name, e.g. 'VIDEOTRON'. Empty for address blocks not announced in BGP.
- `as_number` (number): Just the AS number, as a number, e.g. 5769. Null when there is none.
- `as_organization` (text): Just the organization half of the same field.
- `autonomous_system` (text): The autonomous system as ip-api writes it, e.g. 'AS5769 Videotron Ltee'. Empty for address blocks not announced in BGP.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `hosting` (true/false): True for an address in a data centre or hosting provider, which is what a server or a bot usually calls from. Null when ip-api reported nothing.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `isp` (text): The internet provider serving the address.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `mobile` (true/false): True for a cellular connection. Null when ip-api reported nothing, which is not the same as false.
- `organization` (text): The organization the address is registered to, which is often the business behind it rather than the provider.
- `proxy` (true/false): True for a proxy, a VPN or a Tor exit node. Null when ip-api reported nothing, which is not the same as false.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `reverse_dns` (text): The host name the address points back to. Empty unless the step asked for it, since that lookup is slower.

**Example output**

```json
{
  "as_name": "VIDEOTRON",
  "as_number": 5769,
  "as_organization": "Videotron Ltee",
  "autonomous_system": "AS5769 Videotron Ltee",
  "country": "Canada",
  "country_code": "CA",
  "hosting": false,
  "ip": "24.48.0.1",
  "isp": "Le Groupe Videotron Ltee",
  "location_label": "Montreal, Quebec, Canada",
  "mobile": false,
  "organization": "Videotron Ltee",
  "proxy": false,
  "query": "24.48.0.1",
  "reverse_dns": "modemcable001.0-48-24.mc.videotron.ca"
}
```

### Get an IP address's time zone

Get the time zone an address sits in and the time there right now, so a message goes out in someone's working hours rather than the middle of their night. The offset already has daylight saving applied. The country's currency comes with it.

**Inputs**

- IP address or domain (`ip_address`, text, required): The IPv4 address, IPv6 address or domain name to look up. A domain is resolved by ip-api and the address it resolves to is what gets located. A whole URL is accepted too: only its host is used.

**Outputs**

- `city` (text): The city, e.g. 'Montreal'.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `currency` (text): The country's currency code, e.g. 'CAD'.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `local_time` (text): The time it is at that address right now, e.g. '2026-08-24T15:22:04-04:00'.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `timezone` (text): The IANA time zone, e.g. 'America/Toronto'.
- `utc_offset` (text): The same offset written the usual way, e.g. '-04:00'.
- `utc_offset_seconds` (number): How far the time zone is from UTC in seconds right now, daylight saving already applied, e.g. -14400.
- `utc_time` (text): The same moment in UTC, for comparison.

**Example output**

```json
{
  "city": "Montreal",
  "country": "Canada",
  "country_code": "CA",
  "currency": "CAD",
  "ip": "24.48.0.1",
  "local_time": "2026-08-24T15:22:04-04:00",
  "location_label": "Montreal, Quebec, Canada",
  "query": "24.48.0.1",
  "timezone": "America/Toronto",
  "utc_offset": "-04:00",
  "utc_offset_seconds": -14400,
  "utc_time": "2026-08-24T19:22:04Z"
}
```

### Look up an IP address

Geolocate an IP address or a domain name: the country, region and city it is in, its coordinates and time zone, the provider that runs it, and whether it is a proxy, a data centre or a mobile network. Give it a domain and ip-api resolves it first, then locates the address behind it. No API key required.

**Inputs**

- IP address or domain (`ip_address`, text, required): The IPv4 address, IPv6 address or domain name to look up. A domain is resolved by ip-api and the address it resolves to is what gets located. A whole URL is accepted too: only its host is used.
- Language (`language`, text): The language to return the city, region and country names in. English by default. Codes such as the two-letter country code are the same in every language. One of: `en` (English), `de` (German (Deutsch)), `es` (Spanish (Espanol)), `pt-BR` (Portuguese, Brazil (Portugues)), `fr` (French (Francais)), `ja` (Japanese), `zh-CN` (Chinese, simplified), `ru` (Russian). Default: `en`.
- Look up reverse DNS (`include_reverse_dns`, true/false): Also return the host name the address points back to, e.g. 'wi-in-f94.1e100.net'. Off by default because ip-api warns that this lookup can make the request take noticeably longer. Default: `false`.

**Outputs**

- `as_name` (text): The AS's short registry name, e.g. 'VIDEOTRON'. Empty for address blocks not announced in BGP.
- `as_number` (number): Just the AS number, as a number, e.g. 5769. Null when there is none.
- `as_organization` (text): Just the organization half of the same field.
- `autonomous_system` (text): The autonomous system as ip-api writes it, e.g. 'AS5769 Videotron Ltee'. Empty for address blocks not announced in BGP.
- `city` (text): The city, e.g. 'Montreal'.
- `continent` (text): The continent's name, e.g. 'North America'.
- `continent_code` (text): The continent's two-letter code, e.g. 'NA'.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `currency` (text): The country's currency code, e.g. 'CAD'.
- `district` (text): The district within the city, where one is known. Empty for most addresses.
- `hosting` (true/false): True for an address in a data centre or hosting provider, which is what a server or a bot usually calls from. Null when ip-api reported nothing.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `isp` (text): The internet provider serving the address.
- `kind` (text): Whether the located address is 'ipv4' or 'ipv6'.
- `latitude` (number): The latitude of the area the address is in. It locates the network, not a person: treat it as a neighbourhood, not a street address.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `longitude` (number): The longitude of the area the address is in.
- `map_url` (text): A link showing the located point on OpenStreetMap.
- `mobile` (true/false): True for a cellular connection. Null when ip-api reported nothing, which is not the same as false.
- `organization` (text): The organization the address is registered to, which is often the business behind it rather than the provider.
- `postal_code` (text): The postal or zip code, e.g. 'H1K'. Often only the first part of one, since an address covers an area.
- `proxy` (true/false): True for a proxy, a VPN or a Tor exit node. Null when ip-api reported nothing, which is not the same as false.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `region` (text): The region or state's name, e.g. 'Quebec'.
- `region_code` (text): The region or state's short code, e.g. 'QC'. FIPS or ISO depending on the country, and sometimes a number.
- `reverse_dns` (text): The host name the address points back to. Empty unless the step asked for it, since that lookup is slower.
- `timezone` (text): The IANA time zone, e.g. 'America/Toronto'.
- `utc_offset` (text): The same offset written the usual way, e.g. '-04:00'.
- `utc_offset_seconds` (number): How far the time zone is from UTC in seconds right now, daylight saving already applied, e.g. -14400.

**Example output**

```json
{
  "as_name": "VIDEOTRON",
  "as_number": 5769,
  "as_organization": "Videotron Ltee",
  "autonomous_system": "AS5769 Videotron Ltee",
  "city": "Montreal",
  "continent": "North America",
  "continent_code": "NA",
  "country": "Canada",
  "country_code": "CA",
  "currency": "CAD",
  "district": "",
  "hosting": false,
  "ip": "24.48.0.1",
  "isp": "Le Groupe Videotron Ltee",
  "kind": "ipv4",
  "latitude": 45.6085,
  "location_label": "Montreal, Quebec, Canada",
  "longitude": -73.5493,
  "map_url": "https://www.openstreetmap.org/?mlat=45.6085&mlon=-73.5493#map=10/45.6085/-73.5493",
  "mobile": false,
  "organization": "Videotron Ltee",
  "postal_code": "H1K",
  "proxy": false,
  "query": "24.48.0.1",
  "region": "Quebec",
  "region_code": "QC",
  "reverse_dns": "",
  "timezone": "America/Toronto",
  "utc_offset": "-04:00",
  "utc_offset_seconds": -14400
}
```

### Look up several IP addresses

Geolocate a list of addresses in one step - a column of sign-up addresses, the addresses in a log - and get a row for each with where it is and who runs it. Addresses that cannot be located are reported alongside the ones that can, so one private address in the list does not fail the step.

**Inputs**

- IP addresses or domains (`ip_addresses`, list, required): The addresses to look up, as a list or separated by commas. At most 25 in one step: each one is a separate request against ip-api's free allowance of 45 a minute, which every workflow in this workspace shares. Repeats are looked up once.
- Language (`language`, text): The language to return the city, region and country names in. English by default. Codes such as the two-letter country code are the same in every language. One of: `en` (English), `de` (German (Deutsch)), `es` (Spanish (Espanol)), `pt-BR` (Portuguese, Brazil (Portugues)), `fr` (French (Francais)), `ja` (Japanese), `zh-CN` (Chinese, simplified), `ru` (Russian). Default: `en`.

**Outputs**

- `count` (number): How many addresses were asked about.
- `failed` (list): The addresses ip-api refused.
- `failed_count` (number): How many ip-api refused - private, reserved or unreadable.
- `located` (list): The addresses that were located.
- `located_count` (number): How many of them were located.
- `not_checked` (list): The addresses left untried. Run the step again for these once the allowance resets.
- `not_checked_count` (number): How many were left untried because the minute's allowance ran out mid-list.
- `requests_made` (number): How many requests this step made to ip-api.
- `requests_remaining` (number): How many lookups ip-api says are left in the current minute, from its X-Rl header. Null if it did not say.
- `results` (list): One row per address that was tried, in the order given.
- `seconds_until_reset` (number): How many seconds until that allowance resets, from ip-api's X-Ttl header. Null if it did not say.

**Example output**

```json
{
  "count": 2,
  "failed": [
    "192.168.1.1"
  ],
  "failed_count": 1,
  "located": [
    "24.48.0.1"
  ],
  "located_count": 1,
  "not_checked": [],
  "not_checked_count": 0,
  "requests_made": 2,
  "requests_remaining": 43,
  "results": [
    {
      "city": "Montreal",
      "country": "Canada",
      "country_code": "CA",
      "hosting": false,
      "ip": "24.48.0.1",
      "isp": "Le Groupe Videotron Ltee",
      "latitude": 45.6085,
      "located": true,
      "location_label": "Montreal, Quebec, Canada",
      "longitude": -73.5493,
      "mobile": false,
      "proxy": false,
      "query": "24.48.0.1",
      "reason": "",
      "region": "Quebec",
      "timezone": "America/Toronto"
    },
    {
      "city": "",
      "country": "",
      "country_code": "",
      "hosting": null,
      "ip": "",
      "isp": "",
      "latitude": null,
      "located": false,
      "location_label": "",
      "longitude": null,
      "mobile": null,
      "proxy": null,
      "query": "192.168.1.1",
      "reason": "private range",
      "region": "",
      "timezone": ""
    }
  ],
  "seconds_until_reset": 58
}
```

### Look up this workflow's IP address

Look up the address this workflow's requests go out from, and where it is. That is Lodol's own outbound address, not the address of whoever is watching the workflow, which is what you need when a third-party API asks you to allow-list the address your calls arrive from.

**Inputs**

- Language (`language`, text): The language to return the city, region and country names in. English by default. Codes such as the two-letter country code are the same in every language. One of: `en` (English), `de` (German (Deutsch)), `es` (Spanish (Espanol)), `pt-BR` (Portuguese, Brazil (Portugues)), `fr` (French (Francais)), `ja` (Japanese), `zh-CN` (Chinese, simplified), `ru` (Russian). Default: `en`.
- Look up reverse DNS (`include_reverse_dns`, true/false): Also return the host name the address points back to, e.g. 'wi-in-f94.1e100.net'. Off by default because ip-api warns that this lookup can make the request take noticeably longer. Default: `false`.

**Outputs**

- `as_name` (text): The AS's short registry name, e.g. 'VIDEOTRON'. Empty for address blocks not announced in BGP.
- `as_number` (number): Just the AS number, as a number, e.g. 5769. Null when there is none.
- `as_organization` (text): Just the organization half of the same field.
- `autonomous_system` (text): The autonomous system as ip-api writes it, e.g. 'AS5769 Videotron Ltee'. Empty for address blocks not announced in BGP.
- `city` (text): The city, e.g. 'Montreal'.
- `continent` (text): The continent's name, e.g. 'North America'.
- `continent_code` (text): The continent's two-letter code, e.g. 'NA'.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `currency` (text): The country's currency code, e.g. 'CAD'.
- `district` (text): The district within the city, where one is known. Empty for most addresses.
- `hosting` (true/false): True for an address in a data centre or hosting provider, which is what a server or a bot usually calls from. Null when ip-api reported nothing.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `isp` (text): The internet provider serving the address.
- `kind` (text): Whether the located address is 'ipv4' or 'ipv6'.
- `latitude` (number): The latitude of the area the address is in. It locates the network, not a person: treat it as a neighbourhood, not a street address.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `longitude` (number): The longitude of the area the address is in.
- `map_url` (text): A link showing the located point on OpenStreetMap.
- `mobile` (true/false): True for a cellular connection. Null when ip-api reported nothing, which is not the same as false.
- `organization` (text): The organization the address is registered to, which is often the business behind it rather than the provider.
- `postal_code` (text): The postal or zip code, e.g. 'H1K'. Often only the first part of one, since an address covers an area.
- `proxy` (true/false): True for a proxy, a VPN or a Tor exit node. Null when ip-api reported nothing, which is not the same as false.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `region` (text): The region or state's name, e.g. 'Quebec'.
- `region_code` (text): The region or state's short code, e.g. 'QC'. FIPS or ISO depending on the country, and sometimes a number.
- `reverse_dns` (text): The host name the address points back to. Empty unless the step asked for it, since that lookup is slower.
- `timezone` (text): The IANA time zone, e.g. 'America/Toronto'.
- `utc_offset` (text): The same offset written the usual way, e.g. '-04:00'.
- `utc_offset_seconds` (number): How far the time zone is from UTC in seconds right now, daylight saving already applied, e.g. -14400.

**Example output**

```json
{
  "as_name": "VIDEOTRON",
  "as_number": 5769,
  "as_organization": "Videotron Ltee",
  "autonomous_system": "AS5769 Videotron Ltee",
  "city": "Montreal",
  "continent": "North America",
  "continent_code": "NA",
  "country": "Canada",
  "country_code": "CA",
  "currency": "CAD",
  "district": "",
  "hosting": false,
  "ip": "24.48.0.1",
  "isp": "Le Groupe Videotron Ltee",
  "kind": "ipv4",
  "latitude": 45.6085,
  "location_label": "Montreal, Quebec, Canada",
  "longitude": -73.5493,
  "map_url": "https://www.openstreetmap.org/?mlat=45.6085&mlon=-73.5493#map=10/45.6085/-73.5493",
  "mobile": false,
  "organization": "Videotron Ltee",
  "postal_code": "H1K",
  "proxy": false,
  "query": "24.48.0.1",
  "region": "Quebec",
  "region_code": "QC",
  "reverse_dns": "",
  "timezone": "America/Toronto",
  "utc_offset": "-04:00",
  "utc_offset_seconds": -14400
}
```

### Measure the distance to an IP address

Measure how far an address is from a point you name, in kilometres and miles - which office, store or region a visitor is nearest. It is a straight line over the globe, not a route, and it measures to the area the address is in rather than to a street.

**Inputs**

- IP address or domain (`ip_address`, text, required): The IPv4 address, IPv6 address or domain name to look up. A domain is resolved by ip-api and the address it resolves to is what gets located. A whole URL is accepted too: only its host is used.
- Latitude to measure from (`latitude`, number, required): The latitude of the place to measure from, between -90 and 90. From -90 to 90.
- Longitude to measure from (`longitude`, number, required): The longitude of the place to measure from, between -180 and 180. From -180 to 180.

**Outputs**

- `city` (text): The city, e.g. 'Montreal'.
- `country` (text): The country's name, e.g. 'Canada', in the language that was asked for.
- `country_code` (text): The country's ISO 3166-1 alpha-2 code, e.g. 'CA'. The same in every language, so this is what to branch on.
- `distance_km` (number): The straight-line distance in kilometres, to one decimal place.
- `distance_miles` (number): The same distance in miles.
- `from_latitude` (number): The latitude that was measured from.
- `from_longitude` (number): The longitude that was measured from.
- `ip` (text): The IP address ip-api located. The same as what was asked for, unless a domain name was: then it is the address that domain resolves to.
- `latitude` (number): The latitude of the area the address is in. It locates the network, not a person: treat it as a neighbourhood, not a street address.
- `location_label` (text): The place in one line, e.g. 'Montreal, Quebec, Canada', ready to put in a message.
- `longitude` (number): The longitude of the area the address is in.
- `map_url` (text): A link showing the located point on OpenStreetMap.
- `query` (text): What this step looked up, exactly as it was given: an address, a domain name, or empty for this server's own address.
- `timezone` (text): The IANA time zone, e.g. 'America/Toronto'.

**Example output**

```json
{
  "city": "Montreal",
  "country": "Canada",
  "country_code": "CA",
  "distance_km": 545.6,
  "distance_miles": 339.0,
  "from_latitude": 40.7127837,
  "from_longitude": -74.0059413,
  "ip": "24.48.0.1",
  "latitude": 45.6085,
  "location_label": "Montreal, Quebec, Canada",
  "longitude": -73.5493,
  "map_url": "https://www.openstreetmap.org/?mlat=45.6085&mlon=-73.5493#map=10/45.6085/-73.5493",
  "query": "24.48.0.1",
  "timezone": "America/Toronto"
}
```