AU Mobile Coverage — phone signal checker for Telstra, Optus and Vodafone/TPG 4G/5G, at an address or along a road trip

Will my phone work here, and which carrier is best? Grade any Australian coordinates — a house, a campsite, a fleet depot, or a whole road trip resampled every few kilometres (give it "origin": "Brisbane QLD", "destination": "Melbourne VIC" and it routes the drive for you) — against the carriers' own predicted-coverage models, the same data behind their 4G and 5G coverage maps. One row per point with Telstra, Optus and TPG/Vodafone 4G / 5G grades (TPG also gives predicted dBm), plus a run summary that says how many kilometres of your route are Good, Moderate, Basic or No Coverage on each network and exactly where the weak and dead stretches are: the mobile black spots and no-signal dead zones on your road.

The grades are the ones the carriers publish under the ACMA Mobile Network Coverage Maps Industry Standard 2026: every Australian mobile network operator must map 4G and 5G on a common predictive model with four grades — Good / Moderate / Basic / No Coverage — at 100 m resolution, outdoor at ground level, refreshed at least quarterly. That makes the vocabulary identical across carriers and stable enough to build on. This Actor reads the carriers' public coverage checkers (Telstra's and TPG's point lookups, Optus's map tiles); it does not measure anything itself.

What you get

Field	Meaning
carriers.telstra.data['4G'], ['5G']	Telstra retail network (Telstra, Boost). 5G is the better of 5G_NSA (non-standalone, what most handsets use) and 5G_SA (standalone).
carriers.optus.data['4G'], ['5G'], ['5G_NSA'], ['5G_SA']	Optus network (Optus, amaysim, Coles Mobile, Moose, Southern Phone…).
carriers.tpg.data['4G'], ['5G'], ['5G_NSA'], ['5G_SA'], dbm, responseType	TPG Telecom / Vodafone network (Vodafone, TPG, iiNet, Kogan, Lebara, felix, Swoop…). The only carrier that publishes the predicted signal strength in dBm per technology. 5G_SA is the N-band (standalone-capable) grade, 5G_NSA the X-band grade MVNO plans are limited to.
carriers.telstra_wholesale.data	Optional. Telstra's wholesale (MVNO) footprint — Aldi, Belong, Woolworths, Tangerine, More, Exetel… — which is smaller than retail. No NSA/SA split.
best['4G'], best['5G']	Best grade across the requested carriers and which carriers achieve it — "will any phone work here".
point.routeKm	Route samples only: distance along the route.
status	ok = every requested carrier answered; partial = at least one carrier unknown; unknown = none answered (not charged).

Every carrier block carries status, source (name, URL, attribution, model vintage), retrievedAt and, on failure, error. No Coverage is a real answer from the carrier's model. unknown is a fetch or decode failure and must never be read as "no coverage".

The run summary is written to the key-value store as OUTPUT (and the Console status line): per carrier and for the cross-carrier best, grade counts, route kilometres per grade, and weak4G / dead4G stretches (consecutive samples graded Basic-or-worse / No Coverage) with start/end km and coordinates. When both telstra and telstra_wholesale are requested, telstraWholesale.differsFromRetail lists the points where the MVNO footprint is graded lower than retail on 4G or 5G — the "Aldi versus Boost" question, answered per run. On a 1,700 km inland route in Sep 2026 they did not differ at all.

Sample row

{
    "input": { "id": "pilliga", "index": 2, "kind": "point" },
    "point": { "lat": -30.6135, "lng": 149.5766 },
    "status": "ok",
    "carriers": {
        "telstra": {
            "status": "ok",
            "data": { "4G": "Basic", "5G": "Basic", "5G_NSA": "No Coverage", "5G_SA": "Basic", "product": "retail" },
            "source": {
                "id": "telstra.coverage.retail",
                "name": "Telstra mobile coverage map (retail network) — ACMA-standard prediction",
                "url": "https://www.telstra.com.au/coverage-networks/our-coverage",
                "licence": "unofficial endpoint; Telstra website terms apply",
                "attribution": "Coverage grades © Telstra Corporation Limited"
            },
            "retrievedAt": "2026-09-11T09:20:11.412Z",
            "durationMs": 231
        },
        "optus": {
            "status": "ok",
            "data": {
                "4G": "Basic",
                "5G": "No Coverage",
                "5G_NSA": "No Coverage",
                "5G_SA": "No Coverage",
                "layerVersion": "v079"
            },
            "source": {
                "id": "optus.coverage",
                "name": "Optus mobile coverage map (SpatialBuzz tiles) — ACMA-standard prediction",
                "url": "https://www.optus.com.au/living-network/coverage",
                "licence": "unofficial endpoint; Optus website terms apply",
                "attribution": "Coverage grades © Singtel Optus Pty Limited",
                "vintage": "model updated 24/08/2026, layer set v079"
            },
            "retrievedAt": "2026-09-11T09:20:11.398Z",
            "durationMs": 188
        }
    },
    "best": {
        "4G": { "grade": "Basic", "carriers": ["telstra", "optus"] },
        "5G": { "grade": "Basic", "carriers": ["telstra"] }
    },
    "note": "Carrier-predicted outdoor ground-level coverage under the ACMA Mobile Network Coverage Maps Industry Standard 2026 (100 m grid, reviewed at least quarterly). Not a measurement; does not apply indoors or inside a vehicle. Unofficial endpoints.",
    "meta": { "retrievedAt": "2026-09-11T09:20:11.412Z", "durationMs": 240 }
}

Sample OUTPUT summary (route)

{
    "points": 61,
    "routePoints": 61,
    "routeKm": 1494.9,
    "stepKm": 25,
    "carriers": {
        "telstra": {
            "points": {
                "4G": { "Good": 21, "Moderate": 21, "Basic": 14, "No Coverage": 4, "unknown": 0 },
                "5G": { "…": "…" }
            },
            "routeKm": {
                "4G": { "Good": 519.9, "Moderate": 525, "Basic": 350, "No Coverage": 100, "unknown": 0 },
                "5G": { "…": "…" }
            },
            "weak4G": [
                {
                    "fromKm": 250,
                    "toKm": 300,
                    "km": 50,
                    "from": { "lat": -28.43, "lng": 150.98 },
                    "to": { "lat": -28.55, "lng": 150.31 },
                    "points": 2,
                    "worst": "No Coverage"
                }
            ],
            "dead4G": [{ "fromKm": 250, "toKm": 275, "km": 25, "…": "…" }]
        },
        "optus": { "…": "…" }
    },
    "best": { "…": "same shape, best of the requested carriers at each sample" }
}

GeoJSON output

The same result, as geometry: an RFC 7946 FeatureCollection in the key-value record GEOJSON (its own record because a long route at a small step is thousands of features; OUTPUT.geojson = { "record": "GEOJSON", "features": N }). It is for rendering your own map — Leaflet, MapLibre, QGIS, geojson.io, a notebook, or an agent with a plotting tool loads it in one step. This Actor returns data, not images: you pick the style, colours and basemap.

• Route: one LineString per consecutive pair of samples, graded as the sample it starts at (the same [fromKm, toKm) convention as routeKm and the stretches). Properties: fromKm, toKm, km, <carrier>4G / <carrier>5G for each requested carrier (telstra4G, optus5G, telstra_wholesale4G…), best4G, best5G, dead4G (true if any requested carrier is No Coverage on 4G), worst4G.
• Points: one Point per point-mode row with index, id (echoed), per-carrier grades, best4G, best5G.
• Positions are [lng, lat]. An unknown grade is null — draw it as "no data", never as No Coverage.
• It is a straight segment between samples, not the road geometry between them; for a smoother line use a smaller stepKm.

{
    "type": "Feature",
    "geometry": {
        "type": "LineString",
        "coordinates": [
            [143.978, -38.54],
            [143.8, -38.6]
        ]
    },
    "properties": {
        "kind": "route",
        "index": 5,
        "fromKm": 45.2,
        "toKm": 60,
        "km": 14.8,
        "telstra4G": "Basic",
        "telstra5G": "No Coverage",
        "optus4G": "No Coverage",
        "optus5G": "No Coverage",
        "best4G": "Basic",
        "best5G": "No Coverage",
        "dead4G": true,
        "worst4G": "No Coverage"
    }
}

Use cases

• Mobile reception at an address before you rent, buy or move: which carrier has Good 4G or 5G at the house, and which only Basic.
• Which carrier is best along this road: kilometres of Good / Moderate / Basic / No Coverage per network for a whole drive, in one run.
• Road trip and outback planning: where the phone signal drops out, how long each dead zone lasts, and whether any network covers it (best).
• Mobile black spots on a regular route: a freight run, a school bus route or a farm road, re-checked after each quarterly model refresh.
• Campsite and caravan park reception: grade a list of campgrounds or free camps as points and keep the ones with 4G.
• Remote-area work sites and fleet depots: which SIM to issue for a crew or a vehicle tracker that has to stay connected.
• Boost or ALDI Mobile? Both resell Telstra, but Boost gets the retail network and ALDI, Belong, Woolworths and other MVNOs the smaller wholesale footprint; request telstra_wholesale to grade both, point by point.
• Vodafone/TPG signal strength in dBm: the only carrier that publishes a predicted number, not just a grade.
• Coverage map data for your own app or dashboard: GeoJSON segments coloured by grade, no screen-scraping of four different coverage checkers.
• Agents answering "will I have signal at X?": one call returns all carriers under the same ACMA grades.

Input

Field	Type	Notes
points	array	{ "lat", "lng", "id"? } objects (lon, latitude/longitude also accepted), or { "address", "id"? } to have the address geocoded.
addresses	array	Street addresses or place names, one per line, geocoded for you (paid plans; $0.001 each on the routing actor). See Addresses.
origin	string	Start of a route to be computed for you: a place name or address ("Brisbane QLD") or "lat,lng". Needs destination. See Route by name.
destination	string	End of that route, same forms.
waypoints	array	Optional stops in between, in order: place names or "lat,lng" strings, same forms as origin. Up to 18. See Why waypoints.
profile	string	Travel mode for origin/destination: car (default), bike, foot, truck, motorcycle, scooter, bus, taxi.
polyline	string	Encoded polyline of a route — Google Directions overview_polyline.points, OSRM, Mapbox, Valhalla. Wins over coordinates and origin.
polylinePrecision	5 | 6	5 for Google and OSRM's default, 6 for Mapbox / Valhalla / OSRM polyline6. Default 5.
coordinates	array	Alternative to polyline: [lat, lng] pairs, latitude first like everywhere else. Wins over origin.
stepKm	number	Route sample spacing, default 5. The models are 100 m grids; 5 km catches town/scrub transitions on a highway, 1 km is thorough.
carriers	array	Any of telstra, optus, tpg, telstra_wholesale. Default [\"telstra\", \"optus\", \"tpg\"].
concurrency	1–8	Default 4. Requests per carrier host are capped independently of this (see Politeness).

points and a route can be combined; point rows come first, then route samples in order with routeKm. The easiest route input is origin + destination (see below). If you bring your own route, pass the directions polyline, not your own resampled points: a coordinate list is treated as the route geometry, so coarse samples are joined by straight lines and the route comes out shorter than the road (and the samples land off it). Up to 5000 points per run including route samples — raise stepKm or split the route if you hit it. Coordinates outside Australia are skipped with a warning (points) or rejected (route vertices). If you already have directions from another API, pass its polyline; otherwise give origin and destination.

{
    "points": [{ "id": "melbourne-flinders-st", "lat": -37.8183, "lng": 144.9671 }],
    "polyline": "…overview_polyline from Google Directions…",
    "stepKm": 5,
    "carriers": ["telstra", "optus", "tpg"]
}

Route by name

{ "origin": "Brisbane QLD", "destination": "Melbourne VIC", "stepKm": 5 }

With origin and destination (and optional waypoints and profile), the Actor asks the Directions, Routing & Distance Matrix API actor (davidar/openstreetmap-directions-api) for the route, then samples it every stepKm exactly as if you had passed its polyline. Place names are geocoded within Australia; a town name resolves to the town centre, which is fine for a drive between towns. Use "lat,lng" (for example "-27.4648,153.019") when the exact start matters.

Why waypoints. The router takes the shortest road, not the one you will drive, and route choice moves the answer more than the checker does. Goondiwindi → Dubbo unrouted leaves the Newell Highway at Coonabarabran for the Mendooran back road, which has about 30 km with no Telstra coverage; if you are driving the Newell via Gilgandra, say so with "waypoints": ["Gilgandra NSW"] and grade that road instead. Waypoints take the same forms as origin and destination — place names or "lat,lng" strings — up to 18.

What it costs. The routing actor runs under your account, so its charges appear on that actor in your Apify billing, not on this one: one route_computed ($0.003), one geocoded_location ($0.001) per place name (two for the example above — coordinates are free) and Apify's standard actor-start event for a 512 MB run. This Actor charges coverage_point per sample as before and adds no event of its own. Brisbane → Melbourne by name at 5 km is about $0.005 of routing plus ~340 samples.

Free Apify plans get the routing actor's community-router tier: coordinates only, car only — place names, addresses and other profiles come back unsupported. Pass "lat,lng" origins and destinations, coordinates in points, or a polyline.

Addresses. addresses (strings) and points given as {"address": "12 Smith St, Fitzroy VIC 3065", "id": "smith-st"} are geocoded through the same routing actor in one nested run — one geocoded_location ($0.001) per address that resolves, billed on that actor, nothing for one that doesn't — and then graded exactly like coordinate points. The row keeps what you sent in input.address and what the geocoder matched in input.label; check the label when the address was vague. The routing actor's word-match rule applies, so a bare street name can't resolve to a shop in another state: an address that cannot be placed is listed in OUTPUT.geocoding.failed with the reason, is not graded and is not charged. Up to 1000 addresses per run. Forms that resolve well: a full street address with suburb and postcode (12 Smith St, Fitzroy VIC 3065), a town (Coonabarabran NSW), or a landmark name on its own (Flinders Street Station). A landmark followed by a comma and the city (Flinders Street Station, Melbourne VIC) makes the geocoder read the city as the place and can fail — drop the comma or the city.

If the route can't be found (a place name that matches nothing, no road between the points, the routing service down), the run stops before grading anything, charges nothing here, and the status message says why. The routing actor may still charge for place names it resolved before the route failed ($0.001 each) and its start event; see its pricing. OUTPUT then holds only route: { actor, runId, error } and warnings, so you can trace the routing run:

route lookup failed: geocode_failed: no match for "Nowhereville" — pass a polyline or coordinates instead

Too many samples. The 5000-point cap is checked before the routing actor is called when every location is "lat,lng" (straight-line distance × 1.2); with place names it can only be checked on the routed line, and then the run fails with the route's length and the smallest stepKm that fits — the route is computed and billed on the routing actor, so pick stepKm from the drive's length (1,700 km at 0.5 km is ~3,400 samples).

Spending limit. The routing run is a separate run with its own charge cap ($0.10, or this run's spending limit if lower); what it charges (about $0.025 with 20 place names) is not counted against this run's Maximum cost per run.

Scoped API tokens. If you run this Actor with a scoped API token in Restricted mode, give it Run permission on davidar/openstreetmap-directions-api and access to default run storages, or pass a polyline.

Precedence. polyline wins over coordinates, which wins over origin/destination; the ignored input is named in a warning. A coordinates list with no valid pair doesn't count, so origin/destination are used. points combine with any of them.

The run summary in OUTPUT gains a route block when the route was computed for you:

{
    "route": {
        "actor": "davidar/openstreetmap-directions-api",
        "runId": "…",
        "profile": "car",
        "distanceKm": 1719.4,
        "durationMin": 1078.2,
        "locations": [
            { "query": "Brisbane QLD", "label": "Brisbane, QLD, Australia", "lat": -27.4648, "lng": 153.019 },
            { "query": "Melbourne VIC", "label": "Melbourne, VIC, Australia", "lat": -37.8183, "lng": 144.9671 }
        ],
        "warnings": []
    }
}

distanceKm / durationMin are the routing engine's figures for the whole drive (routeKm in the summary is the same road, measured along the decoded geometry). locations echoes each input with what a place name matched — check label before trusting a long route. warnings relays the routing row's warnings. route is absent when you passed a polyline or coordinates.

Coverage of carriers

Network	Retail brands it answers for	Source	4G	5G NSA / SA
Telstra	Telstra, Boost	Telstra coverage checker (point lookup)	✅	✅ / ✅
Telstra wholesale	Aldi, Belong, Woolworths, Tangerine, More, Exetel, Lebara…	Telstra coverage checker, wholesale product	✅	combined 5G only
Optus	Optus, amaysim, Coles, Moose, Southern Phone, Dodo, iPrimus…	Optus coverage map tiles	✅	✅ / ✅
TPG / Vodafone	Vodafone, TPG, iiNet, felix, Kogan, Lebara, Swoop, Moose, Lyca	TPG/Vodafone coverage checker (point lookup, with dBm)	✅	✅ / ✅

TPG's published map is the union of its own network and the regional Optus network it shares (MOCN), so regionally a TPG grade often matches Optus's; in metro areas it is TPG's own footprint.

Reading the grades

The ACMA standard's own descriptions: Good — high-quality experience with seamless connectivity; Moderate — generally reliable, some variability; Basic — connectivity may be limited or intermittent (calls and texts, data may struggle); No Coverage — predicted signal below −115 dBm.

Things the standard itself says, which apply to every row here:

• Outdoor, ground level. Indoor and in-vehicle coverage is not modelled and is generally worse. A "Basic" grade on a highway is what you get standing beside the car with the phone held up, not on a call through the windscreen.
• A prediction, not a measurement. Terrain, foliage, buildings and handset quality all move the real result. Treat Basic-or-worse stretches as "plan for no signal".
• Grid is 100 m. Points are graded on the cell they fall in; two rows 50 m apart can differ.
• Refreshed quarterly. Optus's source.vintage carries the model date its map reports; Telstra's checker does not expose one.

Also: 5G is "any 5G". A site with 5G_SA only (Telstra flags these coverage5GSAOnly) needs a standalone-capable handset and plan; 5G_NSA is the common case. Telstra's own checker headline is the NSA grade — this Actor reports the better of the two and gives you both.

TPG's dbm values sit on the ACMA thresholds the checker returns alongside them: Good ≥ −95 dBm, Moderate ≥ −105, Basic ≥ −115, No Coverage below. Two "Good" points at −70 and −94 dBm are the same grade and a world apart in practice — the number is worth keeping.

Politeness and reliability

All three sources are the carriers' public, unauthenticated coverage checkers — not documented APIs. The Actor keeps at most 2 requests in flight to each of Telstra and TPG, ≥120 ms apart, and caches Optus tiles per run (one 256 px tile covers ~3.9 km, so nearby points cost nothing extra). A 1,500 km route at 5 km spacing is ~300 Telstra calls, ~300 TPG calls and ~900 Optus tile fetches, and takes about two minutes.

If a carrier redeploys its map the block for that carrier comes back unknown with a clear error; other carriers are unaffected. The Optus tile layer version and legend are read from the map's configuration at the start of each run and verified with one known tile before any point is graded, and TPG's API base is read from the map's runtime config, so a rolled version is handled without a redeploy of this Actor. Please open an issue if a carrier stays unknown for more than a day.

Pricing

Pay-per-event: one coverage_point event per row that at least one carrier answered (status ok or partial), whatever the number of carriers requested. Rows with status: unknown are not charged. No platform-usage pass-through. A route given by origin/destination is computed by the Directions, Routing & Distance Matrix API actor and billed on that actor (about $0.005 for a two-place-name route), outside this run's spending limit; a failed route lookup charges nothing here, though the routing actor may still charge its start event and $0.001 per place name it resolved before the route failed.

Limitations

• Australia only (bounding box check on input; the carriers have nothing to say elsewhere).
• No 3G (shut down 2024), NB-IoT, or fixed-wireless layers, though Optus publishes them.
• Routing is delegated to the Directions, Routing & Distance Matrix API actor (billed there, see Route by name). A coordinate list joined by straight lines between towns is not the highway; give origin/destination or the real polyline.
• Grades are those published by the carriers on the day; they are not archived, so re-running later can differ after a model refresh.

For agents and pipelines

• Join on input.id (echoed) or input.index (0-based position in the combined point + route list).
• With origin/destination, read OUTPUT.route.locations[].label to confirm what the place names matched; a route-lookup failure ends the run with no rows, a route lookup failed: … status message and an OUTPUT holding only route.{actor, runId, error} and warnings.
• Read OUTPUT from the default key-value store for the summary; don't recompute stretches from rows unless you need a different threshold.
• For a map, read the GEOJSON record (see GeoJSON output) rather than rebuilding lines from rows.
• Check status and each carrier's status before reading grades. best[tech].grade is null only when every requested carrier is unknown at that point.
• Route stretches are half-open: [fromKm, toKm), where each sample stands for the route up to the next sample. A single weak sample is one stepKm long.

FAQ

Where are the mobile black spots on my road trip?

Give origin and destination (add waypoints for the road you will actually drive) and read OUTPUT: dead4G lists every No Coverage stretch per carrier with start and end km and coordinates, weak4G every Basic-or-worse one, and best says whether any network covers each stretch.

Which carrier is best at this address or along this road?

Pass the address's coordinates as points (or the route) with all carriers. Each row's best names the carriers with the best grade there; for a route, OUTPUT.carriers.<carrier>.routeKm gives kilometres per grade, so the carrier with the most Good and the fewest No Coverage kilometres wins. Addresses must be coordinates here; for a place name, use it as a route's origin.

Is this a real signal measurement?

No. It is each carrier's own prediction under the ACMA coverage standard, outdoor at ground level, on a 100 m grid; indoors and inside a car are worse. Only Vodafone/TPG publishes a predicted signal strength in dBm; Telstra and Optus give the grade only. See Reading the grades.

Does it cover Boost, ALDI Mobile, Belong, amaysim, Felix…?

Yes, through the network each brand runs on: see Coverage of carriers. Telstra's MVNOs other than Boost use the smaller wholesale footprint, so request telstra_wholesale for them.

How do I use it from an AI agent (MCP), n8n, Make or my own code?

Through the Apify MCP server (mcp.apify.com) an agent can find this Actor with search-actors, read this README and call it with the fields in the Input section. From n8n, Make, Zapier or your own code, use Apify's integration for that tool or the Apify API and client libraries with the same input JSON. Join rows back to your input on input.id or input.index, and read counts from the dataset or OUTPUT, not from the run summary, which can lag the dataset by a second or two. See For agents and pipelines.

Disclaimer

Coverage grades are © the respective carriers and are reproduced as published by their public coverage checkers under the ACMA industry standard; this Actor is not affiliated with Telstra, Optus, TPG Telecom, SpatialBuzz, Mapshed or the ACMA. Coverage is predicted, outdoor-only and changes over time. Verify before relying on it for safety-critical purposes.