> ## Documentation Index
> Fetch the complete documentation index at: https://www.algolia.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Algolia for Make

> Automate indexing and search workflows with the Algolia app for Make.

Use the [Algolia app for Make](https://apps.make.com/algolia-com) 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](https://www.make.com) account
* Your Algolia application ID and an [API key](/doc/guides/security/api-keys) 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.

1. In Make, create a scenario and click **+** to add a module.
2. Search for **Algolia** and select a module.
3. Click **Create a connection**.
4. Enter your Algolia application ID and API key.
5. 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](/doc/rest-api/search) 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.

<Steps>
  <Step title="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.
  </Step>

  <Step title="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](/doc/guides/sending-and-managing-data/prepare-your-data).
  </Step>

  <Step title="Test the scenario, then turn it on">
    Click **Run once**, then inspect the new records in the [Algolia dashboard](https://dashboard.algolia.com/explorer). If the records match what you expect, [set the scenario's schedule](https://help.make.com/schedule-a-scenario) and turn the scenario on to run it automatically.
  </Step>
</Steps>

### 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](/doc/rest-api/search/batch):

* **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](/doc/rest-api/search/search-single-index):

* **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](https://www.make.com/en/ai-agents), where the agent decides which tools to call, use the [Algolia Public MCP server](/doc/guides/model-context-protocol/public-mcp) instead of the Algolia app. Connect it with Make's generic [MCP Client](https://www.make.com/en/integrations/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](/doc/guides/scaling/algolia-service-limits#application-record-and-index-limits) that depends on your plan.
* Batch requests are subject to the [same limits as the API](/doc/guides/sending-and-managing-data/send-and-update-your-data#send-records-in-batches).
* Every module run consumes Make operations. To index several items per run, prefer [one batch request](#process-several-items-per-run).
* For large imports, prefer an [API client](/doc/libraries/sdk/install) or [connector](/doc/guides/sending-and-managing-data/send-and-update-your-data/connectors/overview).

## See also

* [Algolia on Make](https://www.make.com/en/integrations/algolia-com): browse templates and apps you can combine with Algolia
* [Algolia for n8n](/doc/integration/n8n)
* [Algolia for Zapier](/doc/integration/zapier)