# Apify → Airtable Pusher (`robertsong13/apify---airtable-pusher`) Actor

Push results from the most recent Apify task run directly into Airtable Table. Deduplicated and production-ready.

- **URL**: https://apify.com/robertsong13/apify---airtable-pusher.md
- **Developed by:** [Grant Robertson](https://apify.com/robertsong13) (community)
- **Categories:** Automation, Integrations, Lead generation
- **Stats:** 2 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Apify → Airtable Results Pusher

Push results from the **most recent run** of any Apify **task or actor** directly into **Airtable** — safely, predictably, and without duplicate runs.

This actor is designed as **workflow glue** between Apify and Airtable.\
It does **not** scrape, rerun tasks, or process historical data.

***

### Why use this actor

- Works with **Apify Tasks and Actors**
- Uses **ONLY** the most recent run
- Optional **SUCCEEDED-only** safety check
- Prevents duplicate pushes with a **run-lock**
- Simple, predictable **create-only writes**
- Writes **only fields that already exist** in Airtable
- Designed for **production workflows**

***

### How it works (high level)

1. Paste your Apify Task or Actor URL (or ID)
2. Enter your Airtable Base ID and Table Name
3. Run the actor

Only the **latest run** is ever used.\
The same run will never be pushed twice.

***

### ⚠️ Important recommendation (read this first)

#### Use **one Airtable table per Apify task or actor**

For best results, it is **strongly recommended** to:

- Create a **new Airtable table for each Apify task or actor**
- Avoid mixing outputs from multiple scrapers into the same table

#### Why this matters

Different actors produce different fields.

Airtable:

- Has strict column types
- Does not handle dynamic schemas well

Mixing schemas leads to:

- Column type errors
- Skipped fields
- Partial writes
- Hard-to-debug failures

Keeping **one table per actor** ensures:

- Clean schema
- Predictable writes
- Easier automation
- Fewer errors

This is standard practice in production data pipelines.

***

### Quick start (2 minutes)

1. Run an Apify task or actor **at least once**
2. Create a **new Airtable table**
   - Default primary field is fine
3. Generate an Airtable **personal access token**
4. Paste:
   - Apify Source URL
   - Airtable Base ID
   - Airtable Table Name
5. Run the actor

***

### How Airtable columns are handled (very important)

#### This actor does **NOT** create Airtable columns automatically

Instead, it follows a **safe, intentional schema model**:

- The actor inspects the Airtable table
- It checks which **columns already exist**
- It writes **only fields that match existing column names**
- All other fields are skipped

This prevents:

- Accidental schema pollution
- Invalid column types
- Unusable tables

***

### Partial schema matching (key concept)

You do **not** need to add every dataset field as a column.

#### Rules:

- At least **2 matching columns** must exist
- If fewer than 2 fields match:
  - No records are written
  - The actor logs **exactly which fields you may want to add**

***

### ⭐ How to create missing columns (step-by-step)

If the actor cannot find enough matching columns:

1. Open the **Run logs** in Apify
2. Look for messages like:

Not enough matching columns.
Airtable has: name, company
You may want to add columns like:
email, job\_title, profile\_url, location

3. Go to your Airtable table
4. Create **any columns you want** using those names\
   (you do NOT need to add them all)
5. Rerun the actor

As soon as **2 or more fields match**, the actor will:

- Write all matching fields
- Skip the rest
- Proceed normally

This gives you **full control** over your Airtable schema.

***

### What this actor does

- Pulls results from **ONLY the most recent run**
- Writes **new Airtable records** (no upserts)
- Flattens nested JSON into Airtable-friendly fields
- Writes **only matching Airtable columns**
- Skips unknown fields safely
- Prevents duplicate runs from being processed twice
- Handles Airtable rate limits safely

***

### What this actor does NOT do

- ❌ Does **not** start or rerun Apify tasks or actors
- ❌ Does **not** scrape or crawl websites
- ❌ Does **not** process historical runs
- ❌ Does **not** auto-create Airtable columns
- ❌ Does **not** dedupe rows inside Airtable

If you need scraping or enrichment, run those actors **before** this one.

***

### Required inputs

#### Apify Source URL

Paste one of:

- Task URL
- Actor URL
- Task ID
- Actor ID

Only the **most recent run** is used.

#### Airtable credentials

- **API Key** (personal access token)
- **Base ID** (e.g. `appXXXXXXXXXXXXXX`)
- **Table Name**

***

### Deduplication (run-lock)

Run-lock prevents pushing the **same Apify run** more than once.

This makes the actor safe to:

- schedule
- rerun
- automate

⚠️ This is **run-level deduplication**, not row-level deduplication.\
New runs will always create new records.

***

### Pricing

Billed per Airtable record processed.

- **$1 per 1,000 records**
- Example: 2,500 records → $2.50
- A small actor start fee may also apply

***

### Common issues

#### “No runs found”

Run your Apify task or actor at least once.

#### “Latest run status is not SUCCEEDED”

Fix the upstream run and rerun it.

#### “No records written”

Check the logs:

- You likely have fewer than 2 matching Airtable columns
- The logs will list suggested column names to add

#### Airtable column errors

Usually caused by:

- Wrong column type
- Mixing schemas in one table

Creating a **new table per actor** almost always resolves this.

***

### Recommended workflow

Apify Task or Actor (scheduled)
↓
Apify → Airtable Results Pusher (this actor)
↓
Airtable (CRM, ops, pipelines, reporting)

***

### Summary

This actor is intentionally **simple and opinionated**:

- You control the Airtable schema
- The actor never mutates it
- Logs tell you exactly what to add
- Runs are safe, repeatable, and predictable

If you want a reliable bridge between Apify and Airtable — without surprises — this actor is built for that.

# Actor input Schema

## `sourceUrl` (type: `string`):

Paste an Apify Task URL, Actor URL, Task ID, or Actor ID. Only the most recent run is used.

## `airtableApiKey` (type: `string`):

Airtable personal access token.

## `airtableBaseId` (type: `string`):

Example: appXXXXXXXXXXXXXX

## `airtableTableName` (type: `string`):

Table where records will be created or updated.

## `apifyApiToken` (type: `string`):

Required only if the source task/actor belongs to a different Apify account or organisation.

## `onlySucceeded` (type: `boolean`):

If enabled, the actor errors if the most recent run is not SUCCEEDED.

## `runLock` (type: `boolean`):

Prevents pushing the same Apify run more than once.

## `maxItems` (type: `integer`):

Maximum number of dataset rows to process from the latest run.

## `flattenObjects` (type: `boolean`):

Flatten nested JSON objects into Airtable-friendly fields.

## `requestsPerSecond` (type: `integer`):

Throttle requests to avoid Airtable rate limiting.

## `dryRun` (type: `boolean`):

Simulate processing without creating or updating records.

## Actor input object example

```json
{
  "onlySucceeded": true,
  "runLock": true,
  "maxItems": 1000,
  "flattenObjects": true,
  "requestsPerSecond": 4,
  "dryRun": false
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing all billing rows pushed to Airtable.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("robertsong13/apify---airtable-pusher").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("robertsong13/apify---airtable-pusher").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call robertsong13/apify---airtable-pusher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=robertsong13/apify---airtable-pusher",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/j9uvMvEc1EcLv8W8e/builds/CyFCGaTrgwpkWElco/openapi.json