ArcGIS FeatureServer Extractor

Point at ANY Esri ArcGIS REST layer and get clean, flat feature rows.

The ArcGIS REST API (…/FeatureServer/<id>/query and …/MapServer/<id>/query) is the single most common government / civic GIS surface in North America. Practically every US city, county, DPW, state DOT, MPO, HUD, USGS office and utility publishes its open data through an Esri ArcGIS Server or ArcGIS Online instance — that's thousands of layers behind one uniform protocol. The Apify Store has only per-instance clones; this is the generic runner. One actor turns any ArcGIS layer into structured rows — no per-site scraper.

Typical job: you found a public ArcGIS map (a city permit layer, a HUD or USGS dataset, a county parcel service) and want its records as a spreadsheet or JSON, with coordinates, without writing code against the REST API.

Quick start (about 1 minute)

1. Open the ready-made example HUD assisted multifamily properties and click Try for free, or paste this input into the Input tab (it is the Actor's default example):

   {
     "where": "1=1",
     "outFields": "*",
     "returnGeometry": true,
     "listLayersOnly": false,
     "maxRecords": 5,
     "pageSize": 5,
     "serviceUrls": [
       "https://services.arcgis.com/VTyQ9soqVukalItT/arcgis/rest/services/Multifamily_Properties_Assisted/FeatureServer/0/query"
     ]
   }
   

2. Click Start. A cloud run with exactly this input returned 5 rows in a few seconds and charged 5 feature events.

3. Open the Output tab and export CSV, JSON or Excel. Each row carries all 284 source attributes of that layer as columns, plus _latitude/_longitude in WGS84.

4. Swap in your own layer URL. To find the layers behind a service, first run it with List layers only on a …/FeatureServer or …/MapServer root, then copy a queryUrl from the result. Raise maxRecords when the output looks right.

What the quick start returned

Selected columns from that run (the full rows have every attribute):

OBJECTID	PROPERTY_NAME_TEXT	PLACED_BASE_CITY_NAME_TEXT	STD_ST	_latitude	_longitude
1	Capitol Oaks Senior Residences	Atlanta	GA	33.7182	-84.4241
2	Burnt Hill Road Group Home	(empty in source)	NJ	40.4142	-74.6787
3	Villa Maria	Wilmington	DE	39.7517	-75.5416
4	Eastern West Virginia Community Action Agency, Inc	Moorefield	WV	39.0494	-78.9379
5	Christopher Homes of Beebe	Jacksonville	AR	34.8866	-92.1366

Cost: one feature event per row, $0.0005 on the free tier (down to $0.00025 on higher Apify plans), so the quick start is about $0.0025 plus normal platform usage.

Limits: it reads only what the ArcGIS server exposes publicly (or with a token you supply); some servers cap where/paging or return fewer fields; the actor never fills in missing values.

What it does

1. Accepts a layer query URL, a layer URL, or a service root. Give it …/FeatureServer/0/query, …/FeatureServer/0, or a bare …/FeatureServer / …/MapServer root — a root is enumerated into all of its layers automatically.
2. Pages the layer via the standard resultOffset + resultRecordCount, honoring the layer's maxRecordCount and following exceededTransferLimit until the result set is exhausted or your cap is hit. f=json is always sent explicitly.
3. Flattens every feature into one row: every attribute becomes its own column, plus the Esri geometry (_geometry), a computed bounding box (_bbox), _longitude/_latitude for point layers (reprojected from Web Mercator to WGS84 when needed), provenance (_serviceUrl, _layerId, _layerName, _objectId), and a lossless _raw copy of the original Esri feature.

Modes

• Layer catalog — turn on List layers only and give a service root: the actor reads the service descriptor and emits one row per layer (id, name, geometry type, min/max scale, query URL). A cheap map of what a service exposes — then point at a specific layer's /query.
• Features — give one or more layer query URLs (or a root, which expands to all layers), optionally a where clause and an outFields list, and it pages every matching feature.

Input

Field	Description
ArcGIS REST URL(s) (required)	One or more layer query URLs, layer URLs, or service roots. A root is enumerated into its layers. Pre-existing query params (e.g. a token) are preserved.
WHERE clause	SQL-style filter, e.g. STATE = 'CA' or POP > 100000. Default 1=1 (all rows).
Output fields	Comma-separated field names, e.g. OBJECTID,NAME,POP. Default * (all fields).
Return geometry	Include the Esri geometry, _bbox and derived lon/lat. Default on.
List layers only	Discovery: enumerate a service root's layers, fetch no features.
Max records (total)	Cap across all layers/pages. One billable event per feature.
Page size	Server-side records per /query call (resultRecordCount).
ArcGIS token	Optional ?token= for secured services. Never logged.
Bearer token / Extra headers	Optional auth for proxied deployments. Never logged.

Output

One row per feature. Every source attribute is promoted to a top-level column; derived and provenance fields are _-prefixed so a source column can never collide with them:

{
  "OBJECTID": 1,
  "PROPERTY_NAME_TEXT": "Capitol Oaks Senior Residences",
  "HUB_NAME_TEXT": "Atlanta",
  "PLACED_BASE_CITY_NAME_TEXT": "Atlanta",
  "_serviceUrl": "https://services.arcgis.com/VTyQ9soqVukalItT/arcgis/rest/services/Multifamily_Properties_Assisted/FeatureServer/0/query",
  "_layerId": "0",
  "_objectId": 1,
  "_geometryType": "esriGeometryPoint",
  "_spatialReferenceWkid": 3857,
  "_longitude": -84.4241,
  "_latitude": 33.7182,
  "_bbox": [-9398049.15, 3991019.62, -9398049.15, 3991019.62],
  "_attributeKeys": ["HUB_NAME_TEXT", "OBJECTID", "PLACED_BASE_CITY_NAME_TEXT", "PROPERTY_NAME_TEXT"],
  "_attributeCount": 4,
  "_geometry": { "x": -9398049.1585, "y": 3991019.6226 },
  "_raw": { }
}

Point geometries are reprojected to WGS84 _longitude/_latitude; polygon/polyline features get a computed _bbox (in the layer's native SR) and _longitude/_latitude of null. Catalog rows (_mode: "layer") carry _layerName, geometryType, type, minScale/maxScale and queryUrl instead.

Resilience

Per-layer, like a batch harvester. ArcGIS returns HTTP 200 with an {"error": …} body on a bad query — that is detected (not mistaken for success) and the offending layer is a skip-with-warning while the run continues. A dead / 403 / 404 service is skipped too; if every target fails the run exits non-zero (91) so nothing broken ships. A reachable layer whose where matches nothing yields 0 rows and a clean exit — the actor never fabricates rows. A server that ignores resultOffset (repeats the first record) is detected and paging stops to avoid a duplicate loop.

Many government ArcGIS hosts sit behind a WAF that blocks obvious bot User-Agents. The actor sends a standard browser User-Agent so it works across the widest range of public deployments.

Pricing

Pay-per-event: one feature charge per emitted row (feature, or layer in catalog mode). Aggressive subscription-tier volume discounts apply.

Examples

US HUD Multifamily Assisted Properties (ArcGIS Online, 23,781 point features):

{
  "serviceUrls": ["https://services.arcgis.com/VTyQ9soqVukalItT/arcgis/rest/services/Multifamily_Properties_Assisted/FeatureServer/0/query"],
  "where": "1=1",
  "maxRecords": 500
}

Enumerate a service root, then extract (City of Chicago ArcGIS Server):

{
  "serviceUrls": ["https://gisapps.chicago.gov/arcgis/rest/services/SampleWorldCities/MapServer"],
  "listLayersOnly": true
}