Known Issue: ArcGIS Feature Service Reader Limited to 100,000 Records After ArcGIS Online June 2026 Update

Issue

Following the ArcGIS Online June 2026 update, the ArcGIS Feature Service Readers are limited to reading a maximum of 100,000 features from a hosted feature layer.

The Esri ArcGIS Feature Service Readers rely on the Query (Feature Service/Layer) REST endpoint. To obtain a feature count, FME queries this endpoint with returnIdsOnly set to true. Before the June 2026 update, the recordset returned was unbounded — Esri's documentation stated:

"...there is no limit to the number of object IDs returned in the ID array response. Clients can exploit this to get all the query conforming object IDs by specifying returnIdsOnly as true and subsequently requesting feature sets for subsets of object IDs."

Following the update, the number of IDs returned when returnIdsOnly is set to true has been capped at 100,000. Esri has logged this as a bug internally. Safe Software is working closely with Esri to identify a permanent fix.

Workarounds

There are various workarounds for this issue. For Esri-based workarounds, please see Option 1. Options 2 and 3 both involve modifying your workspace and replacing the ArcGIS Feature Service Reader with a transformer-based approach; a ready-made example workspace is available in the files section of this article. Option 2 dynamically generates ObjectID-based WHERE clauses in batches of 100,000. Option 3 is more complex to set up but significantly faster for large datasets, bypassing the reader entirely and using the ArcGIS REST API directly with HTTPCaller pagination to retrieve all records regardless of dataset size.

Option 1- Review the workaround listed in this thread

Esri users are suggesting Esri-based workarounds in this thread. We recommend reviewing this for options that do not require updating workspaces. Based on the comments this may only work to a maximum of 400,000 features.

Option 2 - Dynamically Generate WHERE Clauses Using the ArcGIS Online API

This approach queries the ArcGIS Online API to get the total record count, calculates how many 100,000-record batches are needed, uses a Cloner to generate one feature per batch, builds a WHERE clause for each, and feeds them into a Feature Reader using WHERE_CLAUSE as a fan-out parameter.

1. Add a Creator to the canvas

2. Get total record count with an HTTPCaller

Add an HTTPCaller. Connect the HTTPCaller Input port to the Creator Created output port. Use the HTTPCaller to fetch the total number of records in the feature layer:

• Request URL:

https://<your-service-url>/FeatureServer/<layerId>/query?where=1=1&returnIdsOnly=true&orderByFields=OBJECTID+DESC&f=json&resultRecordCount=1

• HTTP Method: GET

3. Get count with JSONExtractor
Add a JSONExtractor and connect its Input port to the HTTPCaller Output port. Double-click the JSONExtractor to set the following parameters to extract the count value from the response and store it as an attribute:

• JSON Document: response_body
  • Use the drop-down menu to select the attribute
• Target Attribute: count
• JSON Query: json[“objectIds”]

4. Remove the brackets from the result
Add a SubstringExtractor and connect its Input port to the Evaluated output port of the JSONExtractor. In the SubstringExtractor, set up the following parameters.

• Source String: count 
• Start Index: 1
• End Index: -2 
• Result: count

5. Clone one feature per batch

Add a Cloner and connect its Input port to the SubstringExtractor Output port. In the Cloner transformer parameters, set the following:

• Number of Copies: @add((@round((@Value(count)/100000),0)),1)
  • Use the drop-down menu to Open Arithmetic Editor and enter the expression
• Copy Number: _copy_number

This produces one feature per batch, each with a _copy_number attribute starting at 0.

6. Build the WHERE clause per batch

Add an AttributeCreator and connect its Input port to the Cloner Copy output port. Open the AttributeCreator parameters and add the attributes and values in the arithmetic editor from the table below:

7.  Read in features using a FeatureReader

Add a FeatureReader transformer and connect its Initiator input port to the AttributeCreator Output port. In the FeatureReader parameters, set the following:

• Format: Esri ArcGIS Server Feature Service
• Dataset: <Your service URL>
• Feature Types to Read: <Your feature types to read>
• WHERE Clause: where
  • Click the ellipsis to select the where attribute previously created

The FeatureReader will execute one query per incoming feature, each retrieving a distinct 100,000-record batch.

Option 3 — HTTPCaller with Pagination

1. Add a Creator to the canvas

2. Query the Service Metadata
Add an HTTPCaller and connect its Input port to the Creator Output port. Set the following parameters::

• Request URL: <Your feature service layer root URL>
  • Not the /query endpoint. For example: https://<your-service-url>/FeatureServer/<layerId>
• HTTP Method: GET
• Query String Parameters:
  • Name: f
  • Value: pjson 
• Use Authentication: Enabled
  • Authentication Method: Web Connection
  • Web Connection: <Your ArcGIS Online OAuth connection>
• Response Body Attribute: _response_body

This call retrieves the service metadata, which includes the layer type and its maximum record count capabilities.

3. Extract Pagination Metadata
Add a JSONExtractor and connect its Input port to the to the HTTPCaller Output port. Open the parameters and set the following:

• JSON Document: _response_body
• Extract Queries:

These attributes tell you whether the service supports pagination and what its page size limits are.

4. Check Pagination Support
Add a Tester transformer and connect its Input port to the JSONExtractor Evaluated output port.

In the Tester parameters, set the test condition to:

• Left Value: _supportsPagination
• Operator: =
• Value: true

For this method to work, pagination must be supported by the Feature Service. Please see the Esri documentation here: https://developers.arcgis.com/rest/services-reference/enterprise/query-feature-service-layer/

5. Get the Total Record Count
Add a second HTTPCaller and connect its Input port to the Tester Passed output port. Configure the parameters as follows:

• Request URL: <Your service layer query URL>
  • Example: <your-service-url>/FeatureServer/<layerId>/query
• HTTP Method: GET
• Query String Parameters:

• Use Authentication: Enabled
  • Authentication Method: Web Connection
  • Web Connection: <Your ArcGIS Online OAuth connection>
• Response Body Attribute: _response_body

This returns a JSON response containing the total number of features in the layer.

6. Extract the Record Count
Add a second JSONExtractor and connect its Input port to the second HTTPCaller Output port. 

Set the following JSONExtractor parameters:

• JSON Document: _response_body
• Extract Queries:
  • Target Attribute: _count
  • JSON Query: json[“count”]

7. Calculate the Number of Pages
Add an AttributeManager and connect its Input port to the second JSONExtractor Evaluated output port.

In the parameters dialog, add a new attribute:

• Output Attribute: _pages

Click the drop-down arrow under the Value cell and select Conditional Value. In the Conditional Value Definition dialog, double-click into the If Test cell. Set the first test clause:

• Left Value: _type
• Operator: =
• Right Value: Feature Layer
• Value: @Evaluate(ceil(@Value(_count) / @Value(_standardMaxRecordCount)))

Click OK. Double-click into the Else If Test cell and set another test clause:

• Left Value: _type
• Operator: =
• Right Value: Table
• Value: @Evaluate(ceil(@Value(_count) / @Value(_standardMaxRecordCountNoGeometry)))

Also remove the _supportsPagination attribute as it is no longer needed:

• Output Attribute: _supportsPagination
• Action: Remove

This calculates the total number of paginated requests needed to retrieve all features, using the service's own declared page size.
 

8. Clone One Feature Per Page
Add a Cloner transformer and connect its Input port to the AttributeManager oOutput port. Set the following parameters:

• Number of Copies: _pages
  • Use the drop-down to select the attribute
• Copy Number Attribute: _page

This produces one feature per page, each stamped with a _page attribute starting at 0. Each of these features will drive one paginated HTTP request in the following steps.

9. Calculate resultOffset and resultRecordCount
Add a second AttributeManager and connect its Input port to the Cloner Copy output port.

Add two new attributes, following the same process as done in Step 7 using the Conditional Values. For the first attribute, enter the following:

• Output Attribute: _resultOffset
• Value:
  • If:
    • Left Value: _type
    • Operator: =
    • Right Value: Feature Layer
    • Value: @Evaluate(@Value(_page) * @Value(_standardMaxRecordCount))
  • Else If:
    • Left Value: _type
    • Operator: =
    • Right Value: Table
    • Value: @Evaluate(@Value(_page) * @Value(_standardMaxRecordCountNoGeometry))

Click OK. Then add a second attribute:

• Output Attribute: _resultRecordCount
• Value:
  • If:
    • Left Value: _type
    • Operator: =
    • Right Value: Feature Layer
    • Value: _standardMaxRecordCount
      • Use the drop-down the select the attribute value
  • Else If:
    • Left Value: _type
    • Operator: =
    • Right Value: Table
    • Value: _standardMaxRecordCountNoGeometry

These attributes define the exact slice of data each request will retrieve.
 

10. Add a FeatureHolder
Add a FeatureHolder transformer and connect its Input port to the second AttributeManager Output port.
 

11. Generate Temporary File Paths
Add a TempPathnameCreator transformer and connect its Input port to the FeatureHolder Output port. In the transformer parameters dialog, set the following:

• Base Name: features
• Extension: json
• Pathname Attribute: _pathname

These paths provide temporary storage locations for subsequent use within the workspace. In this specific workaround, JSON content is written to these locations and then retrieved via an Esri-JSON FeatureReader.
 

12. Fetch Each Page of Data
Add a third HTTPCaller with its Input port connected to the TempPathnameCreator Output port. Set the following parameters:

• Request URL: <Your service layer query URL>
  • Example: <your-service-url>/FeatureServer/<layerId>/query
• HTTP Method: GET
• Query String Parameters:

• Use Authentication: Enabled
  • Authentication Method: Web Connection
  • Web Connection: <Your ArcGIS Online OAuth connection>
• Save Response Body To: File
• Output Filename: @Value(_pathname)
• Response File Path Attribute: _response_file_path
• Maximum Number of Concurrent HTTP Requests: 4 
  • This limits concurrent requests to avoid throttling
• Retry Failed Requests: Enabled
  • Error Types to Retry: Connection Errors, 429, 500-511
    • Click the ellipsis to select the errors
  • Maximum Rettry Attempts: 3
  • Initial Backoff Time (msec): 500

Each feature drives one paginated query, saving the full Esri JSON response to its unique temp file.

13. Parse the Response into Features
Add a FeatureReader and connect its Input port to the third HTTPCaller Output port. Open the parameters dialog and set the following:

• Format: Esri-JSON (Esri JavaScript Object Notation)
• Dataset: @Value(_response_file_path) 
  • This is the temp file written by HTTPCaller_3
• Parameters:
  • Flatten Nested JSON Values into Attributes: Yes

Connect the Result output port to your downstream transformers or writer. The FeatureReader parses each saved JSON response file into features to be used in the workspace. 

14. Expose Attributes
To expose the attributes from the FeatureReader, you can either expose them from the dataset or from the data cache. 

If you wish to expose from the data cache, run the workspace with data caching enabled. Then, import the features via a data cache.


 

For more information on the ArcGIS Feature Service Query REST API, see Esri's documentation.