Connecting ArcGIS Field Maps to Google Sheets with Make.com eliminates manual data transcription, keeps field records current in real time, and gives distributed teams a shared source of truth. These 7 steps cover everything from account setup to error handling so your integration runs without intervention.

What You Get When ArcGIS Field Maps Talks to Google Sheets

Field data collection breaks down at the handoff point. Surveyors, inspectors, and archaeologists capture precise geolocation entries in ArcGIS Field Maps — then someone spends hours re-keying those records into a spreadsheet. That handoff is where errors enter and momentum dies.

An automated integration through Make.com removes that handoff entirely. Every new feature submission in ArcGIS Field Maps triggers an instant row insertion in Google Sheets — no copy-paste, no export file, no waiting. The result is a live, collaborative dataset your whole team can act on from any location.

If you want to understand how Make.com scenario logic works before you build, read What Is a Make Scenario? for a plain-English walkthrough. And if your team is migrating from Zapier, this migration guide keeps your existing workflows intact during the switch.

Step 1: Set Up Your Accounts and Permissions

Before building anything in Make.com, you need active accounts on three platforms: ArcGIS Online (where your Field Maps data lives), Google (for Sheets access), and Make.com (the automation layer between them).

In ArcGIS Online, confirm that your Feature Layer has edit submissions enabled and that you have at least a Publisher-level account. Make.com connects to ArcGIS through its REST API, so your layer must be publicly accessible or you must generate an OAuth token for private layers.

In Google, create the destination spreadsheet and define your column headers before you build the scenario. Make.com maps fields by column name, so headers set in advance prevent misalignment later.

Connect both services inside Make.com under Connections. Grant the required scopes for Google Sheets (read/write) and ArcGIS (query and edit on the target layer). Permissions set up correctly here save significant debugging time downstream.

Step 2: Build the ArcGIS Trigger Module

Open Make.com, create a new scenario, and add the first module. Make.com does not have a native ArcGIS connector in its standard module library, so use the HTTP — Make a Request module pointed at the ArcGIS Feature Layer REST endpoint.

Set the module to poll for new features added since the last run using the where query parameter filtered by CreationDate > {{last_run_timestamp}}. Use a Make.com data store to persist the timestamp between runs so you never re-process the same record twice.

Schedule the scenario to run at whatever interval fits your field team’s pace — every 15 minutes is a practical starting point for most survey operations. For higher-frequency needs, consider a webhook-based trigger if your ArcGIS Enterprise deployment supports outbound webhooks.

For teams new to HTTP modules and API-based triggers, the guide on feeding API docs into Claude to build Make HTTP modules walks through the exact process without requiring developer experience.

Step 3: Map Your Data Fields Precisely

Data mapping is where integrations break. ArcGIS Feature Layers return a JSON response with an attributes object containing every field in your schema — field names, data types, and values. Google Sheets expects flat text or numbers in specific columns.

Inside Make.com’s visual mapper, parse the JSON response from your HTTP module and pull each attribute value into the corresponding Google Sheets column. Common ArcGIS field types and how to handle them:

• Text fields — Map directly to Google Sheets text columns. No transformation needed.
• Integer / double fields — Map directly. Make.com preserves numeric types without conversion.
• Date fields — ArcGIS stores dates as Unix timestamps in milliseconds. Use Make.com’s formatDate() function to convert to human-readable format before inserting into Sheets.
• Coded value domains — ArcGIS returns the raw code, not the label. If you need the human-readable label, either maintain a lookup table in Google Sheets or decode the value inside Make.com using a Router + filter pattern.
• Geometry fields — Handled separately in Step 5.

Take time with this step. A misaligned mapping that drops data silently is harder to catch than a scenario that fails outright.

Step 4: Configure the Google Sheets Action Module

Add the Google Sheets — Add a Row module after your HTTP trigger. Select your target spreadsheet and the specific sheet tab. Make.com reads your column headers and presents them as named fields in the module configuration.

Drag the mapped values from your HTTP response into the corresponding column fields. The visual interface makes this straightforward — each column header from your Google Sheet appears as a labeled input, and you drop the ArcGIS attribute value into it.

Key settings to configure on this module:

• Value Input Option — Set to USER_ENTERED so Google Sheets interprets dates and numbers correctly rather than treating everything as raw text.
• Insert Data Option — Set to INSERT_ROWS to add new rows without overwriting existing data.
• Spreadsheet ID — Use the dynamic picker rather than hardcoding the ID. This makes the scenario portable if you ever swap the destination sheet.

Once configured, the action module is the least troublesome part of the integration. Most issues appear upstream in the trigger or mapping layers.

Step 5: Handle Geolocation Data Correctly

ArcGIS Field Maps captures geometry as a GeoJSON-style object. A raw point geometry looks like: {"x": -117.1957, "y": 34.0522, "spatialReference": {"wkid": 4326}}. Dropping that object directly into a Google Sheets cell produces an unreadable string.

The right approach is to parse the geometry object inside Make.com and split x and y into separate latitude and longitude columns in your sheet. Add two dedicated columns to your Google Sheet — Latitude and Longitude — then use Make.com’s get() function to extract geometry.y and geometry.x respectively.

If your ArcGIS layer uses a projected coordinate system other than WGS84 (WKID 4326), you need to reproject coordinates before storing them. Either configure your Feature Layer to return WGS84 by appending &outSR=4326 to your REST query, or handle the projection math inside Make.com using a formula module. The &outSR=4326 approach is simpler and eliminates the math entirely.

With clean lat/long columns in your sheet, you can use Google Sheets’ built-in mapping functions or feed coordinates into a separate visualization tool without any additional cleanup.

Step 6: Test and Validate Before Going Live

Testing is not optional. Run the scenario manually against a real feature submission and check every column in the output row. Verify these five things before declaring the integration production-ready:

1. Row completeness — Every column in the sheet has the correct value. No blank fields that should be populated.
2. Date formatting — Timestamps render as human-readable dates, not 13-digit numbers.
3. Coordinate accuracy — Latitude and longitude match what you see in the ArcGIS Field Maps app for the test submission.
4. Duplicate prevention — Submit the same feature twice and confirm only one row appears. Your timestamp-based filter should block re-processing.
5. Special characters — If your field crew uses commas, apostrophes, or non-ASCII characters in text fields, verify they appear correctly in Sheets without breaking the row structure.

Make.com’s scenario tester shows you the full execution log including every module input and output. Use it. A 20-minute test session before go-live prevents hours of data cleanup after the fact.

For a deeper look at evaluating automation scenarios before production, see how to evaluate a Make scenario before it goes live.

Step 7: Add Error Handling So Nothing Gets Lost

Field data collection happens in conditions that break automations — intermittent connectivity, unusual characters in notes fields, geometry objects that don’t parse as expected. A scenario with no error handling drops those records silently.

Make.com’s error handling routes let you define what happens when a module fails. The right setup for this integration:

• On the HTTP module — Add a Resume error handler that writes failed API calls to a separate Google Sheet tab labeled Errors_Log with the timestamp and raw response body. This gives you a recovery queue rather than lost data.
• On the Google Sheets module — Add an Ignore handler for duplicate rows (if your sheet enforces uniqueness) and a Resume handler for API rate limit errors that retries after a short delay.
• Scenario alerts — Enable Make.com’s email notification for consecutive scenario failures. If your ArcGIS token expires or your Google Sheets connection lapses, you want to know within the hour rather than at the next weekly review.

For teams that want a more sophisticated approach, the guide on setting up routed error handling in Make covers multi-branch error routing in detail.

How to Extend This Integration Further

Once the core ArcGIS-to-Sheets pipeline is running, Make.com’s visual scenario builder makes it straightforward to add downstream steps without rebuilding from scratch.

Common extensions teams add after the base integration is stable:

• Automatic chart refresh — Trigger a Google Sheets macro to refresh pivot tables or charts whenever a new row is added, so dashboards stay current without manual intervention.
• Slack or Teams notifications — Add a notification module that alerts a channel when a high-priority feature type is submitted (for example, a defect or safety flag in an inspection workflow).
• PDF report generation — Route new submissions through a document generation tool to produce a formatted field report automatically, using the Google Sheets row as the data source.
• Secondary system sync — Duplicate the row data into a CRM, project management tool, or HRIS depending on your use case, keeping all systems current from a single field submission.

The architecture stays the same — trigger once, route to multiple action modules. Make.com’s 10 automations now easy to build with AI shows how teams are extending these pipelines without developer involvement.

For organizations evaluating how much of this work to handle in-house versus with a partner, the DIY vs. hiring a Make partner guide breaks down when each approach makes sense.

Common Mistakes to Avoid

Teams building this integration for the first time make the same handful of errors. Knowing them in advance saves significant rework:

• Hardcoding the ArcGIS token — OAuth tokens expire. Build your scenario to refresh the token dynamically or store it in a Make.com data store with an expiry check, not as a static string in the HTTP module.
• Skipping the outSR parameter — Projected coordinates in non-WGS84 systems produce lat/long values that look plausible but plot in the wrong location. Always request outSR=4326.
• No deduplication logic — Without a timestamp filter and data store, every scenario run reprocesses all historical features. Your Google Sheet fills with duplicates within days.
• Mapping to column position instead of column name — Make.com’s Google Sheets module supports column-by-name mapping. Use it. Position-based mapping breaks if anyone inserts a column into the sheet.
• Ignoring Google Sheets row limits — A standard Google Sheet supports up to 10 million cells. For high-volume field operations, monitor row counts and build in a monthly archiving step that moves old records to a separate sheet before you hit the limit.

Frequently Asked Questions

Does Make.com have a native ArcGIS connector?

Make.com does not include a dedicated ArcGIS module in its standard connector library. You build the connection using the HTTP — Make a Request module pointed at ArcGIS REST API endpoints. This approach gives you full control over query parameters, authentication, and response handling. The setup takes longer than a native connector but produces a more flexible integration.

What happens if ArcGIS Field Maps submissions come in faster than Make.com polls?

Make.com processes all new features added since the last run timestamp in a single execution. If 50 submissions arrive during a 15-minute polling window, all 50 are processed in the next run through an iterator module. Set your scenario to use an iterator on the returned feature array so each feature gets its own Google Sheets row action. No submissions are skipped as long as your timestamps are maintained correctly in the data store.

Is this integration secure for sensitive field data?

Yes, when configured correctly. Make.com communicates with ArcGIS and Google via OAuth 2.0 and HTTPS. Data in transit is encrypted. Data at rest in Google Sheets is protected by your Google Workspace security policies. For enterprise deployments with stricter requirements, restrict your ArcGIS Feature Layer to authenticated users only and use a dedicated service account for the Make.com connection rather than a personal login.

Can I sync data back from Google Sheets to ArcGIS Field Maps?

Yes. A reverse sync uses a Google Sheets — Watch Rows trigger in Make.com and an HTTP module that sends a POST request to the ArcGIS Feature Layer edit endpoint. This is more complex than the forward sync because you need to handle feature IDs correctly to avoid creating duplicate features. Reverse sync is most useful for workflows where office staff update a record in Sheets and field teams need to see the change in their map.

How do I handle ArcGIS feature attachments like photos?

ArcGIS Field Maps supports photo attachments stored in the Feature Layer’s attachment table, accessible via a separate REST endpoint (/attachments). In Make.com, add a second HTTP module after your main feature query to fetch attachment URLs for each feature ID. Store the attachment URL in a dedicated column in Google Sheets so reviewers can access photos directly from the spreadsheet without logging into ArcGIS.

Additional Reading

• Make.com FAQ: Everything Zapier Users Ask Before Switching
• What Is a Make Scenario? The Plain-English Guide for Zapier Users
• How to Switch From Zapier to Make Without Breaking Your Existing Workflows
• How to Feed API Docs Into Claude to Build Make HTTP Modules Without Native Connectors
• How to Set Up Routed Error Handling in Make With AI Assistance
• How to Evaluate a Make Scenario Built by AI Before It Goes to Production
• 10 Automations That Are Finally Easy to Build With Make + AI — No Developer Needed
• DIY Automation vs. Hiring a Make Partner in 2026: When to Do Each
• Make vs Zapier: A Straight Pricing and Feature Breakdown for 2026
• Data Synchronization: The Unseen Engine of B2B Growth and Profit
• How to Build a Make Scenario With Claude: A Step-by-Step Walkthrough
• AI-Assisted Make Builds vs. Manual Builds (2026): Which Is Better for Your Automation?
• 7 Questions to Ask Before You Automate Anything (The OpsMap Checklist)
• Manual Data Entry: The Silent Killer of Business Productivity & Profit
• Implement AI Workflow Automation: A Step-by-Step Business Guide