Resources · Make integration

FetchFox Make integrationAutomate FetchFox with Make.

Scraped data is only useful once it lands somewhere your team works. The FetchFox Make integration gives you 2 modules: 1 scheduled trigger and 1 open API call. This page shows how to link your FetchFox key and build a first scenario.

Try the FetchFox integration on MakeSee the 2 modules

Verified Trustpilot reviews · AI, automation & growth agency

What you can automate

What can the FetchFox Make integration do for you?

The FetchFox Make integration links your FetchFox account to Make, a no-code tool where you chain apps into a scenario (the automation you build). Make can pick up data FetchFox has scraped and pass it to your other apps, or call the FetchFox API directly when you need something more specific.

Scraped results that file themselves. A marketing team collecting product pages starts the scenario with Watch for Scraped Data, then adds the module of its spreadsheet or CRM. Each new item arrives as a bundle (one row of data moving from module to module) and gets written where people already look.

A FetchFox request fired by another app. An ops lead keeps a list of sites to review in another tool. Make reads that list, then Make an API Call sends each entry to the FetchFox endpoint (one function of its API) of your choice, using the same connection as the trigger.

A gap covered without waiting for a new module. Only 2 modules exist today, so anything outside the trigger goes through Make an API Call. You read the FetchFox API documentation, pick the endpoint, and Make handles the authentication for you.

Keep the limits in mind. FetchFox has no instant trigger in Make, so nothing starts the second a scrape ends. Make also flags its own FetchFox documentation as AI-generated, so check anything important with FetchFox. For the bigger picture on the tool itself, read the Make review; if you are weighing another platform, the n8n vs Make comparison sets out the criteria. And when a run fails, Make troubleshooting walks through the usual causes.

Connect

How do you connect FetchFox to Make?

  1. 01

    Get your FetchFox API key

    You need a FetchFox account and an API key from an AI provider such as OpenAI or OpenRouter. In FetchFox, open the Settings page, go to the API keys section and copy the key shown on screen.

  2. 02

    Add a FetchFox module in Make

    Inside your scenario, search for FetchFox, pick a module and click Create a connection. The connection is your FetchFox account linked to Make once, then reused by both modules. A name in Connection name is optional.

  3. 03

    Paste the key and save

    Paste the FetchFox key into the credentials field, or follow the instructions Make displays, and save. Once the connection works, Make can show you the FetchFox data it is able to read while you fill in the module.

First scenario

Your first scenario with FetchFox and Make

GoalWhen a new site to review shows up in your list app, Make passes it to FetchFox through Make an API Call.

  1. 01

    Create the scenario

    From the Scenarios page, create a new scenario and click the big +. The first module will be the app where your team keeps the list of pages to scrape.

  2. 02

    Set up the source module

    Pick that app, connect your account and choose the list to read. Make shows what it can see once the connection exists, so you point and click instead of typing paths.

  3. 03

    Add Make an API Call

    Click the + on the right of the first module, search for FetchFox and choose Make an API Call. Reuse your FetchFox connection, then enter the endpoint taken from the FetchFox API documentation.

  4. 04

    Map the page from the list

    In the request, drop in the value coming from the first module, such as the address of the page. Make shows the fields of the previous bundle, so mapping is a click, not a copy.

  5. 05

    Test with Run once

    Click Run once. Make runs the scenario a single time and lets you open the bundles each module received, which tells you straight away whether FetchFox accepted the request.

  6. 06

    Schedule and switch it on

    Open the clock on the first module. A new scenario checks every 15 minutes by default, the minimum on the Free plan; paid plans go down to 1 minute. Then switch the scenario on.

Triggers

The FetchFox trigger in Make

1 module starts a scenario when something happens in FetchFox. A scheduled trigger is checked by Make on the scenario's schedule; an instant one is called by FetchFox as soon as it happens.

FetchFox1Watch for Scraped Data

Watch for Scraped Data

triggerIn the docs only

This is the module that turns FetchFox results into a starting point: as its name says, it watches your FetchFox account for scraped data and hands each new item to the rest of the scenario. Make has no official description for it, so check its output with a test.

How it fires
scheduled (deduced from its name, since the documentation only lists it), Make checks the app on the scenario's schedule, every 15 minutes by default.
When to use it
results should reach a sheet, a CRM or a message without anyone exporting them by hand.
Watch out
nothing happens the moment a scrape finishes; the data waits for the next scheduled check, and every check counts as an operation (one run of one module) on your plan.
Modules

The FetchFox action in Make

FetchFox gives you 1 module. For each one: what it does for you, when to reach for it, and what to watch out for.

FetchFox1

Make an API Call

ActionIn the docs only

You get access to the whole FetchFox API from one module, signed in with the connection you already set up, so anything the trigger does not cover is still reachable from your scenario.

When to use it
you want to send a request to FetchFox yourself, for instance with an address coming from another app.
Watch out
Make does not describe the endpoints for you; you pick them in the FetchFox API documentation and fill in the request yourself.
Need help

Need help automating FetchFox with Make?

A person reads every message.

FAQ

FetchFox and Make: common questions

01Is the FetchFox Make integration free?
Yes, on the Make side. FetchFox is a standard app, available from the Free plan. That plan gives you 2 active scenarios, runs spaced at least 15 minutes apart, 5 minutes of execution per run, files up to 5 MB and 512 MB of data transfer. Paid plans (Core, Pro, Teams, Enterprise) lift the interval to 1 minute and the run time to 40 minutes, with usage counted in credits per month. Your FetchFox subscription and the AI provider behind it are separate costs, set by those services.
02What do you need to connect FetchFox to Make?
Three things. First, a FetchFox account. Second, an API key from an AI provider such as OpenAI or OpenRouter, which FetchFox requires to work. Third, your FetchFox API key, found in FetchFox under Settings, then the API keys section. In Make, add a FetchFox module, click Create a connection, optionally name it, and paste the FetchFox key. The same connection then serves both the trigger and Make an API Call, so you only do this once per account.
03Does FetchFox start a Make scenario instantly?
No, as far as the documentation shows. Watch for Scraped Data is listed without an instant tag and reads as a scheduled trigger: Make asks FetchFox for new data each time the scenario runs, and FetchFox does not call Make on its own. A new scenario runs every 15 minutes by default, which is also the shortest gap on the Free plan. On a paid plan you can bring it down to 1 minute. If you need the scenario to start from something else, put another app's module first and reach FetchFox with Make an API Call further down.
04What if the FetchFox module you need is missing in Make?
Use Make an API Call. It lets the scenario call any endpoint of the FetchFox API with the connection you already have, so you are not stuck with the 2 listed modules. You choose the endpoint in the FetchFox API documentation and map the values from earlier modules. One caution: Make marks its FetchFox documentation as AI-generated and possibly wrong in places, so confirm anything important directly with FetchFox before you rely on it in a live scenario.
05Make or n8n for FetchFox?
It depends on the tool your team already uses. In Make, FetchFox comes with one scheduled trigger and an API call module, and the Free plan is enough to test a scenario from start to finish. n8n often has a node for the same app, so check what it offers for FetchFox before choosing. Compare the modules available on each side for your exact use case, then build a small test in the tool your team already knows before moving anything important.
Same platform

Other docs you might need on this stack.

Browse all integrations