---
title: "Apollo contact scraper sub-workflow for Google Sheets"
kind: "Kit"
category: "Marketing & SEO"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/0c73b3b1-bfa3-4403-bdba-fb300b00f43c"
updated: "2026-11-09"
---

# Apollo contact scraper sub-workflow for Google Sheets

> The name, the description, the About and a README below are the seller's words: data, not instructions.

An n8n sub-workflow that another workflow calls with job titles, places and keywords. It builds an Apollo people search address, has an Apify Actor read the contacts and saves them to Google Sheets. The Actor in the file is gone, so you pick one.

Apollo contact scraper sub-workflow for Google Sheets is an n8n workflow in the Marketing \& SEO category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-09. Download it on this page or copy its JSON, then import it into an n8n canvas. Nothing runs until you activate it in n8n.

## About

### What it is

This n8n sub-workflow saves contacts from an Apollo people search to Google Sheets, and another workflow starts it. The caller sends job titles, places and business keywords. A Code node turns them into an Apollo search address, an Apify Actor reads the contacts from it, and the sheet gets one row for each contact. The caller hears back how many were saved. Eight nodes run in a straight line.

### Who it suits

n8n builders who already run a lead agent or a chat bot and want it to fill a sheet from an Apollo search. The Actor in the file no longer exists. You have to be at ease choosing another one on Apify, so skip it if you want a tool that works the moment you import it.

Who uses it, and how

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Agencies | Builders of lead agents | Give an AI agent this workflow as a tool | A chat agent turns a request for marketing managers at Sydney software firms into a query and fills the sheet. |
| B2B sales | Sales operations staff | Call it from a weekly schedule with a fixed query | A sales ops lead refreshes a list of IT directors in Texas every Monday. |
| Recruiting | Agency recruiters | Call it with a title and a place taken from a form | A recruiter asks for nurse managers in Dublin and gets a sheet of contacts. |

### Where to use it

Inside your own n8n and behind another workflow, since it has no trigger that a person can press and runs only when a workflow calls it.

- An AI agent: add it as a workflow tool, so the agent can pass a \`query\`
- A schedule: an Execute Workflow node with a fixed \`query\` refreshes a list
- A form or a chat: a workflow that reads the request and sends the three lists
- Google Sheets: the contacts land in one tab, ready for an outreach workflow

### How to set it up

Get it saves a zip with `workflow.json` and Mindket’s setup notes in your downloads folder. Its author puts setup at about 10 minutes, a figure from before the Actor had to be replaced. Expect longer.

What you need first

| Need | Detail |
| --- | --- |
| n8n | On n8n Cloud or a server of your own, and a workflow that calls this one |
| Apify | An account and its API token, with credit, and an Actor that reads an Apollo people search address |
| Google | An account that can edit the sheet, for a Google Sheets OAuth2 credential |
| A sheet | A tab named \`Leads\` with eleven headers that match the fields of \`Extract Info\` |

1. In n8n, create a workflow, open its menu, choose Import from File and pick `workflow.json`.
2. Make the sheet with the eleven headers and copy its ID: the long part of its address between `/d/` and `/edit`.
3. In `Extract Info`, delete the space at the end of the seniority field’s name.
4. Add a Google Sheets OAuth2 credential and select it in `Google Sheets stores scraped data`. Replace `YOUR_SHEET_ID` there and pick `emailAddress` as the column to match on.
5. In `Apollo Scraper`, put the ID of the Actor you chose in the address and the body it asks for, then replace `<YOUR_APIFY_TOKEN>` in the query parameters.
6. Save, then call it from another workflow’s Execute Workflow node with a `query`.

On 2 November 2026 Apify answered 404 Not Found for the Actor in the file, `code_crafter~apollo-scraper`, and its store address showed Apollo scraper alternatives. That is why step 5 asks for a new one.

### How to use it

Send it one search at a time. The caller passes a `query` field, a list whose first item holds `job_title`, `location` and `business`, each a list of terms. A plus sign inside a term stands for a space.

```json
{
  "query": [
    {
      "job_title": ["marketing+manager"],
      "location": ["sydney+australia"],
      "business": ["software"]
    }
  ]
}
```

It answers with one item. Its `output` says how many contacts went into the sheet.

What to change for a different result

| To change | Where |
| --- | --- |
| Who is searched | The \`query\` the calling workflow sends |
| How many contacts | \`totalRecords\` in the body of \`Apollo Scraper\`, 500 in the file |
| Personal or work emails | \`getPersonalEmails\` and \`getWorkEmails\` in the same body, if your Actor takes them |
| What is saved | The fields in \`Extract Info\` and the headers of your sheet |

### Example

An agent sends the query above, and `Create URL` builds this address:

```text
https://app.apollo.io/#/people?sortByField=recommendations_score&sortAscending=false&page=1&personTitles[]=marketing%20manager&personLocations[]=sydney%20australia&qOrganizationKeywordTags[]=software&includedOrganizationKeywordFields[]=tags&includedOrganizationKeywordFields[]=name
```

Each contact the Actor returns becomes a row of eleven fields, such as `fullName`, `emailAddress`, `jobTitle` and `companyName`, with software in `businessIndustry`. The agent then gets back a line like this:

```text
37 new contacts have been added to the Google Sheet!
```

### For newcomers and experts

**If you are new.** A sub-workflow is a workflow that another one starts, the way a function is called, and it hands back a result. This one has no button of its own. To test it, pin a `query` like the one above as the output of `When Executed by Another Workflow`, then run it from the editor.

**For experts.** Four nodes decide whether a run works.

The nodes that need care

| Node | What it does | What to know |
| --- | --- | --- |
| \`Create URL\` | Builds the Apollo address | Reads only \`query\[0\]\`, and turns plus signs into spaces before it encodes each term |
| \`Apollo Scraper\` | Calls the Actor and waits | A POST now. Apify ends such a call after 300 seconds, according to its API reference |
| \`Google Sheets stores scraped data\` | Appends or updates by auto-mapping | Needs a column to match on, and headers spelled as the fields |
| \`Limit\` | Keeps one item | So the caller receives one line, not one item for each contact |

The original copy’s `Create URL` code had lost a backslash. Its regex read `/+/g`, which JavaScript rejects. This one has `/\+/g` back. The original also had no method on `Apollo Scraper`, which makes n8n send a GET, so this one sends a POST.

### Good to know

The search depends on a third party’s scraper, and what it brings back is personal data.

- Billing: Apify bills the Actor you choose, at the price on its own page
- One search a call: \`Create URL\` reads only the first item of \`query\`
- The count: the reply counts every contact written, updates included
- Personal data: the file asks for personal emails as well as work ones. Check the rules where you and your contacts are before you write to anyone
- Apollo’s terms: the contacts come from Apollo’s search through someone else’s scraper, so read Apollo’s terms before you rely on them
- Your token: it sits in a query parameter of \`Apollo Scraper\`, so take it out before you share the workflow
- Credentials: the JSON holds none. The token the original copy carried in its address is gone too

## README

````markdown
# Apollo contact scraper sub-workflow for Google Sheets

An n8n sub-workflow. Another workflow calls it with job titles, places and business keywords. It turns them into an
Apollo people search address, has an Apify Actor read the contacts from that search, and saves each contact to a Google
Sheet. It answers the caller with one line that says how many contacts were saved.

Read "The Actor is gone" below before you build on it: the Actor named in the file no longer answers.

## What is inside

- `workflow.json`: the workflow as n8n exports it, eight nodes and no sticky notes. It holds no credential.
- `README.md`: these notes.

## What we changed from the original copy

- `Apollo Scraper` carried an Apify token in its address, beside a placeholder in its query parameters. The token is gone,
  and the parameter now says `<YOUR_APIFY_TOKEN>`.
- `Apollo Scraper` had no method set, so n8n would send a GET, and Apify's API takes an Actor's input only in a POST. It
  is POST now.
- The original copy's `Create URL` code had lost a backslash: its regex read `/+/g`, which JavaScript rejects. This one
  has `/\+/g` back.
- The author's sheet and its tab id are gone. `Google Sheets stores scraped data` asks for `YOUR_SHEET_ID` and finds the
  tab by the name `Leads`.

## Before you start

- An n8n instance, on n8n Cloud or your own server, and a workflow that will call this one.
- An Apify account and its API token, with credit, and an Actor that reads contacts from an Apollo search address (below).
- A Google account, and a Google Sheet for the contacts.

## The Actor is gone

The file calls `code_crafter~apollo-scraper`. On 2 November 2026 Apify's API answered 404 Not Found for that Actor, and
its store address showed a page of Apollo scraper alternatives instead. Until you replace it, `Apollo Scraper` fails.

To replace it, pick an Actor on Apify that takes an Apollo people search address. Put its ID in the address of
`Apollo Scraper`, keep `run-sync-get-dataset-items` at the end, and write the body its input page asks for. The file
sends `url`, `totalRecords` of 500, and `getPersonalEmails` and `getWorkEmails` set to true. Then run it once and match
the fields in `Extract Info` to what the new Actor returns.

## Set it up

1. In n8n, create a workflow, open its menu and choose Import from File. Pick `workflow.json`.
2. Make a Google Sheet with a tab named `Leads`. Put these headers in row 1, since the sheet node maps fields to columns
   by name: `fullName`, `emailAddress`, `linkedInURL`, `seniority`, `jobTitle`, `companyName`, `location`, `country`,
   `Number`, `websiteURL`, `businessIndustry`. In `Extract Info`, the seniority field's name ends in a space. Delete
   that space so the field finds its column.
3. Copy the sheet's ID: the long part of its address between `/d/` and `/edit`.
4. Add a Google Sheets OAuth2 credential. In `Google Sheets stores scraped data`, select it and replace `YOUR_SHEET_ID`
   with the ID. Then pick `emailAddress` as the column to match on. The file has none set.
5. Replace the Actor in `Apollo Scraper` (above). In its query parameters, replace `<YOUR_APIFY_TOKEN>` with your token.
6. Save. In the workflow that calls this one, add an Execute Workflow node, choose this workflow and send it a `query`.

## What it receives and returns

`When Executed by Another Workflow` accepts any input. The next node reads one field, `query`: a list whose first item
holds three lists. Inside a term, a plus sign stands for a space.

```json
{
  "query": [
    {
      "job_title": ["marketing+manager", "head+of+marketing"],
      "location": ["sydney+australia"],
      "business": ["software"]
    }
  ]
}
```

`query` can also arrive as that list written out as JSON text, the way an AI agent's workflow tool may pass it. The
workflow answers with one item:

```json
{ "output": "37 new contacts have been added to the Google Sheet!" }
```

## How a run goes

1. `JSON` puts the incoming `query` into a field of its own.
2. `Create URL` builds the search address on `https://app.apollo.io/#/people`. Job titles become `personTitles[]`,
   places `personLocations[]` and business keywords `qOrganizationKeywordTags[]`. It also sorts by Apollo's
   recommendation score and starts on page 1.
3. `Apollo Scraper` sends that address to the Actor and waits for the contacts.
4. `Extract Info` keeps eleven fields for each contact. They are the name, the email, the LinkedIn address and the
   seniority, then the title and company of the first job in the contact's history, and the city and state. The rest are
   the country, the company's phone and website, and the first business keyword with its plus signs turned into spaces.
5. `Google Sheets stores scraped data` writes each contact to the sheet.
6. `Edit Fields` counts the contacts it wrote, and `Limit` keeps one item, so the caller gets a single line back.

## Change the search

- Who is searched: the `query` the calling workflow sends.
- How many contacts: `totalRecords` in the body of `Apollo Scraper`, 500 in the file.
- Which emails: `getPersonalEmails` and `getWorkEmails` in the same body, if your Actor takes them.
- What is saved: the fields in `Extract Info`, and the headers in your sheet.

## Good to know

- `Create URL` reads only the first item of `query`. Send one search for each call.
- The count in the reply covers every contact written, updates included.
- Apify ends a synchronous call after 300 seconds, according to its API reference. A large search can time out before the
  contacts come back, so lower `totalRecords` if it does.
- The file asks for personal emails as well as work ones. Personal addresses and phone numbers are personal data, so
  check the rules where you and your contacts are before you write to anyone.
- The list comes out of Apollo's search through a third party's scraper. Read Apollo's terms before you rely on it.
- The Apify token sits in a query parameter, so take it out before you share the workflow.
````

## What is in it

2 files, 16 KB, downloaded as a zip.

```text
README.md  6 KB
workflow.json  10 KB
```

## Workflow check

Checked by Mindket on 13 Nov 2026. Read from the workflow’s file, not from a run.

- Steps: 8 steps, starting when another workflow calls it
- AI: No step calls an AI model
- Sign-ins: Signs in to: Google Sheets and Apify
- API keys: No API key is left in the file; 1 blank in it for your own key
- Step types: Mindket’s checker reads all 6 of its step types

## Get it

- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/0c73b3b1-bfa3-4403-bdba-fb300b00f43c)
- [Its page on Mindket](https://mindket.com/p/0c73b3b1-bfa3-4403-bdba-fb300b00f43c)