Geocoder.ca API — Examples

Quick start Forward Reverse Geoparse Formats Premium-only Server patterns

Geocoder.ca Premium API (Canada + USA)

Geocoder.ca provides a simple HTTPS API for forward geocoding (address → coordinates), reverse geocoding (coordinates → nearest address), and geoparsing (scantext). Output is typically XML, with optional JSON/JSONP and CSV. Keep your auth token on the server whenever possible.

Official premium API page: https://geocoder.ca/?premium_api=1

🍁 Switching from Google Maps? Cache your results, own the database, and estimate what you'd save. Estimate savings →

Quick start (curl)

Replace YOUR_AUTH_TOKEN. Forward lookups use locate. Reverse uses latt, longt, and reverse=1.

CLI

Forward (address → lat,lon) — XML

curl -G 'https://geocoder.ca/' \
  --data-urlencode 'locate=330 metcalfe ottawa on' \
  --data 'geoit=XML' \
  --data 'auth=YOUR_AUTH_TOKEN'

Forward — JSON

curl -G 'https://geocoder.ca/' \
  --data-urlencode 'locate=330 metcalfe ottawa on' \
  --data 'geoit=XML' \
  --data 'json=1' \
  --data 'auth=YOUR_AUTH_TOKEN'

Reverse (lat,lon → nearest address) — XML

curl -G 'https://geocoder.ca/' \
  --data 'latt=45.4215' \
  --data 'longt=-75.6972' \
  --data 'reverse=1' \
  --data 'geoit=XML' \
  --data 'auth=YOUR_AUTH_TOKEN'

Tip: for USA reverse geocoding, add allna=1. If you’re near the border, allna=1 can return both CA + US results.

Core request shapes

Everything is HTTPS to https://geocoder.ca/ via GET or POST.

Reference

Forward geocoding inputs

https://geocoder.ca/?locate={address_or_postal_or_ip}&geoit=XML&auth=YOUR_AUTH_TOKEN

Geoparsing inputs

https://geocoder.ca/?scantext={freeform_text}&geoit=XML&auth=YOUR_AUTH_TOKEN

Reverse geocoding inputs

https://geocoder.ca/?latt={lat}&longt={lon}&reverse=1&geoit=XML&auth=YOUR_AUTH_TOKEN

Forward geocoding examples (locate=…)

Use locate for street addresses, intersections, postal/zip codes, and more.

Many languages

Intersection lookup

curl -G 'https://geocoder.ca/' \
  --data-urlencode 'locate=metcalfe & wellington ottawa on' \
  --data 'geoit=XML' \
  --data 'auth=YOUR_AUTH_TOKEN'

Biasing (country / region / bounds)

curl -G 'https://geocoder.ca/' \
  --data-urlencode 'locate=Springfield' \
  --data 'region=NY' \
  --data 'country=usa' \
  --data 'geoit=XML' \
  --data 'auth=YOUR_AUTH_TOKEN'

Standardized address fields (standard=1)

curl -G 'https://geocoder.ca/' \
  --data-urlencode 'locate=1 valhalla inn road apt 1009 etobicoke on' \
  --data 'standard=1' \
  --data 'showpostal=1' \
  --data 'geoit=XML' \
  --data 'json=1' \
  --data 'auth=YOUR_AUTH_TOKEN'

Python (requests)

import requests

params = {
  "locate": "330 metcalfe ottawa on",
  "geoit": "XML",
  "json": "1",
  "auth": "YOUR_AUTH_TOKEN",
  "standard": "1",
  "showpostal": "1",
}
r = requests.get("https://geocoder.ca/", params=params, timeout=20)
r.raise_for_status()
print(r.text)  # or r.json() if you requested JSON

Node.js (fetch)

const params = new URLSearchParams({
  locate: "330 metcalfe ottawa on",
  geoit: "XML",
  json: "1",
  auth: "YOUR_AUTH_TOKEN",
  standard: "1",
  showpostal: "1",
});

const res = await fetch("https://geocoder.ca/?" + params.toString());
if (!res.ok) throw new Error(await res.text());
console.log(await res.text());

PHP (cURL)

<?php
$q = http_build_query([
  "locate" => "330 metcalfe ottawa on",
  "geoit"  => "XML",
  "json"   => "1",
  "auth"   => "YOUR_AUTH_TOKEN",
  "standard" => "1",
  "showpostal" => "1",
]);

$ch = curl_init("https://geocoder.ca/?$q");
curl_setopt_array($ch, [
  CURLOPT_RETURNTRANSFER => true,
  CURLOPT_TIMEOUT => 20,
]);
$out = curl_exec($ch);
if ($out === false) die(curl_error($ch));
curl_close($ch);

echo $out;

Common forward options: standard=1 (standardized address), strictmode=1 (avoid guesses), decimal=N (limit decimals), showcountry=1, showpostal=1.

Reverse geocoding examples (latt/longt + reverse=1)

Reverse geocoding returns the closest address, plus optional intersection/major intersection and more.

Reverse

Reverse (Canada) — XML

curl -G 'https://geocoder.ca/' \
  --data 'latt=45.415263' \
  --data 'longt=-75.688055' \
  --data 'reverse=1' \
  --data 'geoit=XML' \
  --data 'auth=YOUR_AUTH_TOKEN'

Nearest corner (corner=1)

curl -G 'https://geocoder.ca/' \
  --data 'latt=45.415263' \
  --data 'longt=-75.688055' \
  --data 'reverse=1' \
  --data 'corner=1' \
  --data 'geoit=XML' \
  --data 'auth=YOUR_AUTH_TOKEN'

Reverse (USA) — include allna=1

curl -G 'https://geocoder.ca/' \
  --data 'latt=29.012576' \
  --data 'longt=-80.994220' \
  --data 'reverse=1' \
  --data 'allna=1' \
  --data 'geoit=XML' \
  --data 'auth=YOUR_AUTH_TOKEN'

Places near a point (reverse + POIs)

curl 'https://geocoder.ca/45.415263,-75.688055?pois=1&type=restaurant&radius=200&geoit=xml&auth=YOUR_AUTH_TOKEN'

Reverse options you’ll use most: range=…, exact=1, moreinfo=1, allna=1, corner=1, decimal=N.

Geoparsing examples (scantext=…)

Extract one or more locations from free-form text. Use bounds/country/region to bias results.

scantext

GET (scantext) — JSON

curl -G 'https://geocoder.ca/' \
  --data-urlencode 'scantext=This and That and the Other street in Porters Lake Nova Scotia' \
  --data 'geoit=XML' \
  --data 'json=1' \
  --data 'auth=YOUR_AUTH_TOKEN'

Bias with bounds (SW|NE)

curl -G 'https://geocoder.ca/' \
  --data-urlencode 'scantext=Main Street near the mall' \
  --data 'bounds=34.172684,-118.604794|34.236144,-118.500938' \
  --data 'geoit=XML' \
  --data 'json=1' \
  --data 'auth=YOUR_AUTH_TOKEN'

POST (recommended for long text)

curl -X POST 'https://geocoder.ca/' \
  -d 'scantext=The most important museums of Ottawa are located downtown near Parliament...' \
  -d 'country=canada' \
  -d 'geoit=XML' \
  -d 'json=1' \
  -d 'auth=YOUR_AUTH_TOKEN'

Use country=canada|usa and/or region=ON|QC|NY|CA to reduce ambiguity.

Output formats

Most API examples show XML. JSON/JSONP/CSV are optional.

Formats

JSON

https://geocoder.ca/?locate=330%20metcalfe%20ottawa&geoit=XML&json=1&auth=YOUR_AUTH_TOKEN

JSONP (jsonp=1 + callback=…)

https://geocoder.ca/?locate=330%20metcalfe%20ottawa&geoit=XML&jsonp=1&callback=myFn&auth=YOUR_AUTH_TOKEN

CSV (geoit=CSV)

https://geocoder.ca/?locate=330%20metcalfe%20ottawa&geoit=CSV&auth=YOUR_AUTH_TOKEN

Practical flags you’ll actually use

Great for production robustness + predictable billing.

Ops

strictmode=1 to avoid “best guess” and force suggestions when ambiguous.
topmatches=N to request a fixed number of suggestions for partial inputs.
limit=N to cap results (important for functions that bill per item, like showaddrs).
decimal=N to reduce decimals (smaller response size, lower precision).
standard=1 to request standardized address components in the response.

Premium-only functions (examples)

Autocomplete, show addresses by postal code, polygons, batch tools, and census enrichment.

Premium

Autocomplete (XML + JSON)

# XML
https://geocoder.ca/?autocomplete=1&locate=1435%20prince&geoit=xml&auth=YOUR_AUTH_TOKEN

# JSON
https://geocoder.ca/?autocomplete=1&locate=1435%20prince&geoit=xml&auth=YOUR_AUTH_TOKEN&json=1

showaddrs (postal/zip → many addresses)

# ⚠️ This can spend many credits; use limit=…
https://geocoder.ca/?locate=83313&showaddrs=1&limit=100&geoit=xml&auth=YOUR_AUTH_TOKEN

Batch postal lookup (batchpostal=… | …)

https://geocoder.ca/?batchpostal=K2C1N5|E4L1B3|M2N1N5&geoit=xml&auth=YOUR_AUTH_TOKEN

Postal-in-polygon (postalinpolygon=…)

# Polygon is a pipe-separated list of lat,lon points
https://geocoder.ca/?postalinpolygon=45.4215,-75.6972|45.4315,-75.6972|45.4315,-75.6772|45.4215,-75.6772|45.4215,-75.6972&geoit=xml&auth=YOUR_AUTH_TOKEN

Get polygon for a postal code (getpolygon=1)

https://geocoder.ca/?locate=K2C1N5&getpolygon=1&geoit=xml&auth=YOUR_AUTH_TOKEN

Census enrichment (censusdatafromdauid=…)

https://geocoder.ca/?censusdatafromdauid=59350105&geoit=xml&auth=YOUR_AUTH_TOKEN

For premium functions that return many items (e.g., showaddrs, postalinpolygon), use limit=… where available to control costs.

Server-side patterns (proxy, worker, batch)

Hide your auth token; cache + rate-limit requests.

Architecture

Cloudflare Worker-style proxy (keeps auth private)

export default {
  async fetch(req, env) {
    const u = new URL(req.url);
    const locate = u.searchParams.get("locate");
    if (!locate) return new Response("missing locate", { status: 400 });

    const upstream = new URL("https://geocoder.ca/");
    upstream.searchParams.set("locate", locate);
    upstream.searchParams.set("geoit", "XML");
    upstream.searchParams.set("json", "1");
    upstream.searchParams.set("auth", env.GEOCODER_CA_AUTH);

    const res = await fetch(upstream.toString(), {
      headers: { "Accept": "application/json" },
    });

    return new Response(res.body, {
      status: res.status,
      headers: { "Content-Type": "application/json" },
    });
  }
}

Batch file (bash) — one address per line

# addresses.txt: one address per line
while IFS= read -r addr; do
  curl -sG "https://geocoder.ca/" \
    --data-urlencode "locate=$addr" \
    --data "geoit=XML" \
    --data "json=1" \
    --data "auth=YOUR_AUTH_TOKEN"
  echo
  sleep 0.15   # tune to your plan / rate limits
done < addresses.txt

Production tips: cache results (Redis), normalize into your own schema, add retries + backoff, and keep tokens server-side only.