A verified migration, typed Airtable base, Make.com update loop, and website-ready embed packaged as one working project.
The Airtable Google Sheets Two Way Sync converts an existing Google Sheets dataset into a structured Airtable base, then keeps approved fields current in both systems through Make. It is built for teams that have outgrown copy-paste updates but still need Sheets for familiar editing, Airtable for relational views, and an embedded website view for controlled access.
An Airtable Google Sheets Two Way Sync works by assigning every row a stable sync_key, mapping each column to an explicit Airtable field type, and updating only records that changed. Before creating anything, the workflow checks the shared key; this prevents duplicate records and gives both directions a deterministic update path.
How the Airtable Google Sheets Two Way Sync Prevents Record Drift
A spreadsheet row and an Airtable record can diverge when dates, checkboxes, linked records, or blank values are interpreted differently. This package stores those decisions in a field map rather than relying on automatic type guessing. Each run normalizes values, compares modification timestamps, writes the permitted fields, and records rejected rows for review.
The initial airtable google sheets sync is treated as a controlled migration. Source headers are profiled, field names are cleaned, required columns are checked, and target record counts are reconciled before scheduled updates are enabled.
Core Features
| Feature | Description |
|---|---|
| Typed Airtable Base Builder | Unclear field definitions create broken filters and inconsistent records. The schema file creates text, number, date, checkbox, select, attachment, and linked-record fields from an approved mapping. |
| Validated Sheet Migration | Missing rows are hard to detect after a large import. The migration compares source counts, target counts, unique keys, and rejected records before marking the transfer complete. |
| Google Sheets to Airtable Sync | Re-entering edited spreadsheet rows creates delays and duplicate data. The Make scenario watches changed rows, normalizes values, and creates or updates the matching Airtable record. |
| Airtable to Google Sheets Sync | Teams still using Sheets can miss changes made in Airtable. A second scenario writes approved Airtable fields back to the matching row without replacing formulas or protected columns. |
| Conflict and Loop Protection | Two-way updates can trigger each other indefinitely. The workflow stores sync_source, last_synced_at, and a content hash so unchanged records and self-generated events are ignored. |
| Rejection Queue and Run Log | Silent mapping failures leave teams unsure which system is correct. Invalid dates, missing keys, and unsupported values enter a review table with the source payload and failure reason. |
| Website Embed Package | Publishing the wrong table can expose internal columns. The project creates a filtered read-only view and follows Airtable's view embedding method to produce a responsive iframe snippet. |
Airtable Google Sheets Two Way Sync Architecture
The workflow uses separate directional scenarios rather than one circular scenario. That keeps field permissions, filters, retry rules, and failure logs visible for each path.
Google Sheet
└─ Watch changed rows
└─ Validate + normalize
└─ Find by sync_key
└─ Create/update Airtable
Airtable
└─ Watch changed records
└─ Ignore self-generated updates
└─ Find row by sync_key
└─ Update approved Sheet columns
Shared controls
├─ field-map.json
├─ sync_source
├─ last_synced_at
├─ content_hash
└─ rejection log
For the airtable sync integration google sheets workflow, Make handles triggers and routing, the Airtable Web API handles typed record operations, and the Google Sheets API handles row reads and writes. The scenarios use batches where appropriate, following Google's batch request guidance, while throttling honors published Sheets API usage limits.
Field Ownership and Conflict Rules
Not every field should move in both directions. The mapping declares one of three modes for each field: sheets_master, airtable_master, or two_way. If both systems change a two-way field before the next run, the latest valid timestamp wins and the previous value is written to the audit log. Formula columns, rollups, and Airtable computed fields are read-only by default.
Airtable’s Google Drive sync documentation describes a one-way external-source pattern, so this package uses separate Make scenarios when true two-direction updates are required. The distinction matters: a google sheets to airtable sync can be source-led, while two-way behavior needs explicit loop and conflict controls.
Tech Stack
| Component | Why It Is Used |
|---|---|
| Make scenarios | Provides scheduled and webhook-driven routing, field transformation, branching, retries, and visible run histories for both directions. |
| Airtable schema and API | Preserves field types, views, record identifiers, and linked data rather than flattening the destination into another spreadsheet. |
| Google Sheets API | Reads changed ranges and updates selected cells while leaving formulas, formatting, and protected columns untouched. |
| Mapping and reconciliation scripts | Validate configuration, compare source and target records, and generate a repeatable migration report before scheduled sync is activated. |
| Embed template | Wraps the approved Airtable view in responsive HTML with width, height, loading, and access notes ready for a website editor. |
Project Directory
airtable-google-sheets-two-way-sync/
├── README.md
├── .env.example
├── config/
│ ├── field-map.json
│ ├── sync-rules.json
│ └── connection-settings.json
├── airtable/
│ ├── base-schema.json
│ ├── views.json
│ └── embed.html
├── make/
│ ├── sheets-to-airtable.blueprint.json
│ ├── airtable-to-sheets.blueprint.json
│ └── error-handler.blueprint.json
├── scripts/
│ ├── validate_mapping.py
│ ├── migrate_records.py
│ ├── reconcile_records.py
│ └── requirements.txt
├── reports/
│ ├── migration-summary.csv
│ └── rejected-records.csv
├── tests/
│ ├── test_field_types.py
│ ├── test_duplicate_keys.py
│ └── test_reconciliation.py
└── logs/
└── .gitkeep
Verification Benchmarks
| Check | Acceptance Rule |
|---|---|
| Migration completeness | 100% of source rows receive a migrated, rejected, or intentionally skipped status; no row disappears without a recorded outcome. |
| Record identity | Every synchronized record has one unique sync_key; duplicates block activation until corrected. |
| Scheduled updates | Default polling runs every 15 minutes and can be changed in Make without editing the mapping files. |
| Retry behavior | Temporary API failures receive 3 attempts with increasing delays; permanent validation failures move directly to the rejection queue. |
| Reconciliation | A post-run comparison checks record counts, keys, and tracked values before the run is marked successful. |
Use Cases
- Replace a fragile spreadsheet handoff: Operations teams move an existing Sheet into typed Airtable tables while keeping a familiar spreadsheet available for approved edits.
- Publish controlled website data: Site managers embed a filtered Airtable view without exposing internal notes, hidden fields, or unrelated records.
- Maintain two editing surfaces: Distributed teams update either platform while stable keys, ownership rules, and timestamps prevent duplicate or circular writes.
- Evaluate tools that sync with Google Sheets and Airtable: Technical buyers can inspect the mapping files, Make blueprints, conflict rules, and reconciliation scripts instead of relying on a black-box connector.
For schema changes, extra website fields, or additional endpoints, CogworkLabs provides Airtable sync integration Google Sheets customization together with deployment, monitoring, and maintenance.
How to Synchronize Records Using Airtable Google Sheets Two Way Sync
Download & Set Up the Project
Download, set up, and install Airtable Google Sheets Two Way Sync to get the project running. If you hit any difficulty, contact us here.
Open the Mapping Screen
Open the local setup screen, connect Airtable and Google Sheets, then load the supplied Sheet headers and proposed Airtable field types.
Confirm Sync Rules
Choose each field’s owner, verify the sync_key, select the website view, and set the Make schedule and conflict policy.
Run Migration and Enable Sync
Select Run Migration, review the reconciliation report, then choose Enable Sync to activate both scenarios and copy the generated embed code.
FAQs
How to Sync Airtable With Google Sheets?
Use the supplied Make scenarios to connect the two accounts, map fields, and match records through the shared sync_key. The workflow then watches changes in each system and writes only the fields authorized for that direction.
How Sync Google Sheets to Airtable?
Import the Sheet schema, confirm each Airtable data type, and run the initial migration before enabling the scheduled scenario. After activation, changed rows are validated and matched to Airtable records by their stable key.
Can You Keep a Google Sheet Synced to Airtable?
Yes. The project keeps the Sheet and Airtable base aligned through separate directional scenarios with loop prevention, field ownership, retries, and reconciliation logs. Formula columns and computed Airtable fields remain protected unless they are explicitly mapped as writable.
