> For the complete documentation index, see [llms.txt](https://docs.coupler.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.coupler.io/sources/category/marketing/apify-dataset.md).

# Apify Dataset

Export scraped data from Apify actors into Google Sheets, BigQuery, or databases via Coupler.io — automate web data collection.

Apify is a web scraping and automation platform that lets you extract data from websites using pre-built or custom actors (scrapers). When an actor runs, it stores its output in a **dataset** — a structured collection of items you can export and analyze. Connecting Apify datasets to Coupler.io lets you pull that scraped data into your preferred destination automatically.

## Why connect Apify Dataset to Coupler.io?

* **Centralize scraped data** — move web-extracted data into Google Sheets, BigQuery, Excel, or Looker Studio without manual exports
* **Combine with other sources** — use Append or Join transformations to merge datasets from multiple actors or runs
* **Send to AI tools** — pipe scraped content into ChatGPT, Claude, Gemini, or Perplexity for analysis, summarization, or classification
* **Keep data fresh** — schedule recurring syncs so your destination always reflects the latest actor output

## Prerequisites

* An active Apify account with at least one completed actor run that has produced dataset output
* Your Apify API token (found in Apify Console under **Settings > Integrations**)
* The Dataset ID of the dataset you want to export (found in **Storage > Datasets** in Apify Console)

## Quick start

{% hint style="success" %}
If you want to export items from a website content crawler actor, choose the **Item collection website content crawlers** entity — it maps the crawler output fields automatically.
{% endhint %}

## How to connect

{% stepper %}
{% step %}
**Create a new data flow in Coupler.io.** From your Coupler.io dashboard, click **Add data flow** and search for **Apify Dataset** as your source.
{% endstep %}

{% step %}
**Enter your Apify API token.** In the source settings, paste your API token from Apify Console (**Settings > Integrations > API token**). Coupler.io uses this to authenticate requests on your behalf.
{% endstep %}

{% step %}
**Enter your Dataset ID.** In the **Dataset ID** field, paste the ID of the dataset you want to export. You can find it in Apify Console under **Storage > Datasets** — click on the dataset and copy the ID from the URL or the detail panel.
{% endstep %}

{% step %}
**Choose an entity.** Select one of the available entities depending on what you want to export — see the table below for a quick guide.
{% endstep %}

{% step %}
**Choose a destination.** Pick where you want your data to land — Google Sheets, Excel, BigQuery, Looker Studio, or an AI destination like ChatGPT, Claude, Gemini, Cursor, Perplexity, or OpenClaw.
{% endstep %}

{% step %}
**Run the data flow.** Click **Run** to execute a manual sync and confirm data is flowing correctly before setting up a schedule.
{% endstep %}
{% endstepper %}

## Apify Dataset data overview

Apify datasets store the output of actor runs as structured collections of items — essentially rows of scraped or processed data. The exact fields in each item depend on the actor that produced them, but Coupler.io supports four entities that let you access both metadata and the raw item content.

## Entities and what they return

| Entity                                   | Description                                                                                                 |
| ---------------------------------------- | ----------------------------------------------------------------------------------------------------------- |
| Dataset collections                      | Returns a list of all datasets in your Apify account, including IDs, names, and creation dates              |
| Datasets                                 | Returns metadata for a specific dataset: item count, size, creation date, and last modified time            |
| Item collections                         | Returns the full list of items (rows) stored in a specific dataset — fields vary by actor                   |
| Item collection website content crawlers | Returns items from website content crawlers with standardized fields like URL, page title, and crawled text |

## Available fields

#### Dataset collections fields

| Field            | Description                                          |
| ---------------- | ---------------------------------------------------- |
| `id`             | Unique identifier for the dataset                    |
| `name`           | Dataset name (if set)                                |
| `createdAt`      | Timestamp when the dataset was created               |
| `modifiedAt`     | Timestamp of the last modification                   |
| `accessedAt`     | Timestamp of the last access                         |
| `itemCount`      | Number of items stored in the dataset                |
| `cleanItemCount` | Number of items excluding empty or duplicate records |

#### Dataset metadata fields

| Field            | Description                                         |
| ---------------- | --------------------------------------------------- |
| `id`             | Dataset ID                                          |
| `name`           | Dataset name                                        |
| `userId`         | ID of the Apify user who owns the dataset           |
| `createdAt`      | Creation timestamp                                  |
| `modifiedAt`     | Last modified timestamp                             |
| `itemCount`      | Total item count                                    |
| `cleanItemCount` | Clean item count                                    |
| `actId`          | ID of the actor that created this dataset           |
| `actRunId`       | ID of the specific actor run that produced the data |

#### Item collection fields

Fields vary depending on the actor that produced the dataset. Common fields include:

| Field         | Description                               |
| ------------- | ----------------------------------------- |
| `url`         | The URL that was scraped                  |
| `title`       | Page or record title                      |
| `description` | Short description or meta description     |
| `text`        | Extracted text content                    |
| `price`       | Price (e-commerce actors)                 |
| `imageUrl`    | Image URL                                 |
| Custom fields | Any additional fields output by the actor |

#### Item collection website content crawler fields

| Field      | Description                                |
| ---------- | ------------------------------------------ |
| `url`      | Crawled page URL                           |
| `title`    | Page title                                 |
| `text`     | Full extracted text from the page          |
| `markdown` | Page content in Markdown format            |
| `metadata` | Additional page metadata                   |
| `crawl`    | Crawl metadata (depth, referrer URL, etc.) |

## Common field combinations

* **Content audits**: `url` + `title` + `text` from Item collection to review all scraped pages
* **Dataset monitoring**: `itemCount` + `cleanItemCount` + `modifiedAt` from Datasets to track actor run output over time
* **AI analysis**: `url` + `markdown` from Item collection website content crawlers, piped into ChatGPT or Claude for summarization
* **Cross-dataset comparison**: Use **Append** transformation to stack item collections from multiple actor runs into one unified table

## Use cases by role

{% tabs %}
{% tab title="Marketers" %}

* Pull competitor pricing data scraped by an Apify actor into Google Sheets for weekly tracking
* Send crawled website content to ChatGPT or Gemini for automated content gap analysis
* Append item collections from multiple scraping runs to build a historical dataset of SERP results
  {% endtab %}

{% tab title="Data teams" %}

* Load raw item collections into BigQuery for transformation and analysis at scale
* Join dataset metadata with item collections to enrich records with actor run context (run ID, creation date)
* Schedule syncs to keep a data warehouse table updated after each actor run
  {% endtab %}

{% tab title="Developers" %}

* Use Dataset collections to programmatically audit all datasets stored in an account
* Export item collections to Excel or Looker Studio for stakeholder-ready reporting without writing custom export scripts
* Pipe website content crawler output into Cursor or Claude for AI-assisted code or content generation workflows
  {% endtab %}
  {% endtabs %}

## Platform-specific notes

* Item fields are actor-dependent — the schema of Item collection data will differ between actors (e.g., an e-commerce scraper vs. a news scraper)
* The `cleanItemCount` may be lower than `itemCount` if the actor produced empty or duplicate records
* Apify datasets are tied to a specific actor run; if you re-run an actor, it creates a new dataset with a new ID
* For website content crawlers, the `markdown` field is the most useful for feeding content into AI destinations
* Very large datasets (millions of items) may require pagination — Coupler.io handles this automatically

## Apify Dataset common issues

### Connection issues

<details>

<summary>Authentication failed or API token not accepted</summary>

Double-check that you copied the full API token from Apify Console under **Settings > Integrations**. Tokens are long strings — make sure there are no trailing spaces or missing characters. If you recently regenerated your token, update it in the Coupler.io source settings.

</details>

<details>

<summary>Data flow connects but returns no data</summary>

Confirm that the Dataset ID you entered matches an existing dataset in **Storage > Datasets** in Apify Console. If the actor run failed or produced zero output, the dataset will exist but be empty. Run the actor again in Apify and verify it has items before re-running the data flow.

</details>

### Missing data

<details>

<summary>Only some items are returned, not all</summary>

Apify datasets can be very large. Coupler.io paginates through all items automatically, but if you interrupted a run or the actor run itself was incomplete, the dataset may not contain all expected records. Check the `itemCount` field on the Datasets entity to confirm the expected number of items.

</details>

<details>

<summary>Expected fields are missing from item collection output</summary>

Item fields are defined by the actor, not by Apify or Coupler.io. If a field you expect isn't showing up, the actor may not have produced it in that run (e.g., a page returned no price data). Check the raw dataset in Apify Console to confirm whether the field exists in the source data.

</details>

<details>

<summary>Website content crawler entity returns fewer fields than expected</summary>

The **Item collection website content crawlers** entity uses a fixed set of fields designed for Apify's official website content crawler actors. If you're using a custom or third-party actor that produces different output, use the **Item collections** entity instead to get all raw fields.

</details>

### Permission errors

<details>

<summary>403 Forbidden or "Dataset not found" error</summary>

The dataset you're trying to access may belong to a different Apify user or organization. Your API token only grants access to datasets owned by your account. If you're working in a shared Apify organization, make sure you're using a token with the correct organization scope.

</details>

### Data discrepancies

<details>

<summary>Item count in Coupler.io doesn't match Apify Console</summary>

Apify reports both `itemCount` (all items) and `cleanItemCount` (deduplicated, non-empty items). Coupler.io exports all items by default. If your destination shows fewer rows than `itemCount`, check whether any items were empty objects — these may be filtered depending on your destination settings.

</details>

<details>

<summary>Data from a previous actor run is still showing up</summary>

Each actor run creates a new dataset with a new ID. If your data flow is pointing to the old Dataset ID, it will keep returning data from the old run. After each actor run, update the Dataset ID in your Coupler.io source settings to point to the new dataset.

</details>

### Rate limits

<details>

<summary>Requests are being throttled or failing intermittently</summary>

Apify's API enforces rate limits that vary by plan. If you're running multiple data flows pointing to different datasets simultaneously, you may hit these limits. Stagger your data flow schedules or consolidate related datasets using the Append transformation to reduce the number of API calls.

</details>

## Apify Dataset FAQ

<details>

<summary>Where do I find my Apify API token?</summary>

Go to your Apify Console and navigate to **Settings > Integrations**. Your API token is listed there. Copy the full token and paste it into the Coupler.io source settings when setting up your data flow.

</details>

<details>

<summary>Where do I find the Dataset ID?</summary>

In Apify Console, go to **Storage > Datasets**. Click on the dataset you want to export — the Dataset ID appears in the URL and in the dataset detail panel. It looks like a short alphanumeric string (e.g., `RpXUj3dN9BsLmFv4`).

</details>

<details>

<summary>Which entity should I use — Item collections or Item collection website content crawlers?</summary>

If your actor is Apify's official **Website Content Crawler** (or a compatible variant), use **Item collection website content crawlers** — it maps fields like `url`, `title`, `text`, and `markdown` automatically. For any other actor, use **Item collections** to get all raw fields as the actor produced them.

</details>

<details>

<summary>Can I export data from multiple Apify actor runs at once?</summary>

Yes. Each actor run produces a separate dataset with its own ID. You can create multiple sources within a single Coupler.io data flow — one per Dataset ID — and use the **Append** transformation to combine them into a single table. This is useful for tracking data across weekly scraping runs, for example.

</details>

<details>

<summary>Can I send Apify scraped content to an AI tool like ChatGPT or Claude?</summary>

Yes. Coupler.io supports AI destinations including ChatGPT, Claude, Gemini, Perplexity, Cursor, and OpenClaw. The **Item collection website content crawlers** entity is especially useful here because it provides a `markdown` field with clean, formatted page content that AI models handle well.

</details>

<details>

<summary>My actor ran again and the data hasn't updated — why?</summary>

Each Apify actor run creates a brand new dataset with a new ID. If your data flow is still pointed at the old Dataset ID, it will return data from the old run. You need to update the Dataset ID in your Coupler.io source settings to point to the new dataset after each run.

</details>

<details>

<summary>Can I use Coupler.io to monitor all datasets in my Apify account?</summary>

Yes. Use the **Dataset collections** entity, which returns a list of all datasets in your account along with metadata like `itemCount`, `modifiedAt`, and `actRunId`. This is a good way to build a dashboard that tracks which actors are running and how much data they're producing.

</details>

<details>

<summary>What happens if my Apify dataset is very large?</summary>

Coupler.io paginates through large datasets automatically — you don't need to configure anything special. For very large datasets (hundreds of thousands of rows), we recommend using BigQuery as your destination rather than Google Sheets, which has row limits and can slow down significantly with large payloads.

</details>

{% hint style="info" %}
For a full breakdown of available fields and entities, see [Data Overview](#apify-dataset-data-overview). If you're running into sync problems, check [Common Issues](#apify-dataset-common-issues) for specific fixes.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.coupler.io/sources/category/marketing/apify-dataset.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
