Algolia for Make

Use the Algolia app for Make to add, update, and search records in your indices from any Make scenario. Whenever data changes in your other tools, such as a CMS, database, CRM, or spreadsheet, a scenario can add or update the matching records in Algolia, without writing custom code. Scenarios can also search your indices, to route content, trigger alerts, or retrieve context for AI workflows. Make is a workflow automation platform with a visual editor. Make calls a workflow a scenario, and each step in it a module.

Before you begin

You need:

A Make account
Your Algolia application ID and an API key with permissions for the operations you want to automate

Connect your Algolia account

There’s nothing to install: the Algolia app is part of Make’s built-in app catalog. Add a connection to your Algolia account, then select Algolia modules when building your scenarios.

In Make, create a scenario and click + to add a module.
Search for Algolia and select a module.
Click Create a connection.
Enter your Algolia application ID and API key.
Click Save.

Make stores the connection and reuses it for every Algolia module in your scenarios.

Available modules

Module	What it does
Add a new record (with auto-generated object ID)	Add a record and let Algolia assign its `objectID`
Add or update record attributes	Merge attributes into a record you identify by `objectID`
Get a Record	Retrieve one record by its `objectID`
Search Records	Run a search query on an index
List Indices	List the indices in your Algolia application
Make an API Call	Send an authorized request to any Search API endpoint

Use Make an API Call for operations without a dedicated module, such as batch indexing, deleting records, or updating index settings.

Build an indexing scenario

This example keeps an index in sync with content from another app. The same pattern works with any Make trigger: a webhook, a schedule, or one of Make’s app integrations.

Add a trigger

Create a scenario, then add a trigger module for your data source, for example:

Webhooks, or any trigger labeled INSTANT: your app calls Make, and the scenario runs at once.
A Watch trigger from an app such as Airtable, Notion, or Google Sheets: Make polls your source for new or updated items on the scenario’s schedule.

Send each item to Algolia

Add the Add or update record attributes module and configure it:

Index name: your destination index
Object ID: map a unique, stable identifier from your source data, such as a primary key
Record body: map the attributes that are useful for searching, displaying, filtering, or ranking

Set the object ID yourself so each run updates the same record. The Add a new record (with auto-generated object ID) module assigns a fresh objectID every run, which adds a duplicate each time the same item changes. For more information, see Prepare your records for indexing.

Test the scenario, then turn it on

Click Run once, then inspect the new records in the Algolia dashboard. If the records match what you expect, set the scenario’s schedule and turn the scenario on to run it automatically.

Process several items per run

If your trigger returns an array of items, add an Iterator module, from Make’s built-in Flow control tools, before the Algolia module, so downstream modules run once per item. To index the whole array in a single operation instead, use one Make an API Call module that calls the batch endpoint:

URL: /1/indexes/INDEX_NAME/batch
Method: POST
Body: a requests array with one updateObject action per item, built with Make’s map() function

Handle deletions

To remove records when items are deleted at the source, add a route that triggers on deletion and uses Make an API Call with:

URL: /1/indexes/INDEX_NAME/OBJECT_ID
Method: DELETE

Search from your scenarios

The Algolia app isn’t limited to sending data. To retrieve records as part of a scenario, add a Search Records module and map the query from an earlier module, for example:

Deterministic scenarios: search an index and act on the results, such as routing content, deduplicating entries, or enriching items in other tools.
Retrieval-augmented generation (RAG): search an index for relevant records and pass them as context to an AI module, grounding responses in your own data.

For search parameters the module doesn’t expose, use Make an API Call with the search endpoint:

URL: /1/indexes/INDEX_NAME/query
Method: POST
Body: { "params": "query=QUERY" }

Let an AI agent choose the queries

For scenarios built around Make AI Agents, where the agent decides which tools to call, use the Algolia Public MCP server instead of the Algolia app. Connect it with Make’s generic MCP Client app. This lets agents search your indices and return recommendations, choosing their own queries and parameters at runtime. In short: the Algolia app when your scenario defines the query, the Algolia Public MCP server when the agent does.

Example scenarios

Scenario	What it does	Modules
CMS sync	Keeps search in sync with published content	Webhooks → Add or update record attributes
Product catalog updates	Reflects price and inventory changes in your index	Shopify trigger → Add or update record attributes
AI-enriched records	Enriches records before indexing	App trigger → OpenAI → Add or update record attributes
Web content indexing	Indexes pages from a site you don’t control	Schedule → a scraping app such as Firecrawl → Iterator → Add or update record attributes
RAG chatbot	Answers questions grounded in your indexed content	Webhooks → Search Records → OpenAI

Limitations

Records have a size limit that depends on your plan.
Batch requests are subject to the same limits as the API.
Every module run consumes Make operations. To index several items per run, prefer one batch request.
For large imports, prefer an API client or connector.

​Before you begin

​Connect your Algolia account

​Available modules

​Build an indexing scenario

​Process several items per run

​Handle deletions

​Search from your scenarios

​Let an AI agent choose the queries

​Example scenarios

​Limitations

​See also