canonical: https://jentic.com/apis/algolia.com

# Algolia APIs

Algolia is a hosted search and discovery platform. Its APIs let you index records, run faceted and multi-index queries, ingest data through connectors or a hosted web crawler, capture click and conversion events, and serve recommendations and personalized results built on those events. The Search API is the core surface, and the Recommend, Personalization, and Query Suggestions services build on top of it. Monitoring and A/B Testing sit alongside for cluster health and relevance experiments.

## For AI agents

Index and search records, ingest data through connectors or a web crawler, capture click and conversion events, and serve recommendations and personalized results across nine Algolia APIs.

## Scope

Use for: Algolia search, indexing, ingestion, and the recommendation, personalization, and analytics services built on its indices

Not supported:
- Vector database hosting
- General web hosting
- Payment processing
- Email or SMS delivery

## APIs

| API | Category | Endpoints | Description |
| --- | --- | --- | --- |
| Search API | ai-ml | 78 | Run search queries, index records, manage synonyms and rules, and administer keys and settings on Algolia indices. |
| Ingestion API | developer-tools | 61 | Create and run data connectors that ingest records from external sources into Algolia indices. |
| Algolia Crawler API | developer-tools | 20 | Drive Algolia's hosted web crawler programmatically: create crawlers, run and pause them, test URL extraction, and inspect crawl runs across 20 endpoints. |
| Algolia Monitoring API | developer-tools | 14 | Pull Algolia cluster status, latency, indexing time, and incident data so agents can monitor service health and trigger alerts. |
| Query Suggestions API | ai-ml | 12 | Configure and inspect Algolia query-suggestions indices that power autocomplete, including source index selection, facet eligibility, and rebuild status. |
| Algolia A/B Testing API | analytics | 11 | Create, monitor, and stop search relevance A/B tests on Algolia indices through 11 dedicated endpoints with sample size estimation. |
| Recommend API | ai-ml | 11 | Fetch product recommendations (related, frequently bought together, trending, looking similar) and manage merchandising rules for the Algolia Recommend models. |
| Personalization API | ai-ml | 9 | Configure Algolia personalization strategies and read or delete per-user affinity profiles so search results adapt to each user. |
| Insights API | analytics | 7 | Send click, conversion, and view events to Algolia so Recommend, Personalization, and Dynamic Re-Ranking can learn from user behavior. |

## Which API to use

| Need | API | Why |
| --- | --- | --- |
| Run search queries and manage records, synonyms, and rules | algolia-search-api | The core surface for querying indices and administering their records and settings. |
| Pull data from a database, warehouse, or SaaS source into an index on a schedule | algolia-ingestion-api | Create sources, destinations, and scheduled tasks that ingest external records into indices. |
| Index content from public web pages | algolia-crawler-api | Drive the hosted web crawler to fetch, extract, and reindex site content. |
| Return related items, frequently bought together, or trending recommendations | algolia-recommend-api | Serves recommendation models and their merchandising rules from an objectID. |
| Reorder search results for the current user based on past behavior | algolia-personalization-api | Defines affinity strategies and per-user profiles that Search applies at query time. |
| Send click, conversion, and view events | algolia-insights-api | Captures the behavioral events that Recommend, Personalization, and re-ranking learn from. |
| Power an autocomplete input with suggested queries | algolia-query-suggestions-api | Configures suggestion indices built from search analytics that you then query through Search. |
| Compare two index variants against live traffic | algolia-a-b-testing-api | Creates and measures relevance experiments and estimates the sample size they need. |
| Watch cluster status, latency, and incidents | algolia-monitoring-api | Read-only infrastructure health for status pages and alerting. |

## Cross-API use cases

### Ingest a catalog and make it searchable

Fill an index from an external source and serve queries against it. The agent creates a connector task with the Ingestion API to pull records from a database or warehouse into the products index, then runs faceted queries against that index with the Search API. For web content the Crawler API replaces the ingestion step. The result is a searchable index the agent keeps current without hand-writing a sync job.

Example prompt: Create an Ingestion task that loads a BigQuery source into the products index, wait for the run to finish, then run a faceted query against products and return the top hits.

### Search, then learn from what users click

Turn searches into a training signal. The agent runs a query with the Search API and keeps the returned queryID, then sends click and conversion events tagged with that queryID through the Insights API as users interact. Those events are what the Recommend and Personalization services read, so this loop is the prerequisite for both. The agent builds the behavioral record without a separate analytics pipeline.

Example prompt: Run a query for 'running shoes', capture its queryID, and send a click event and a conversion event for the chosen objectID with that queryID and a user token.

### Serve recommendations from tracked behavior

Add a recommendations surface once behavioral events exist. The agent keeps sending click and conversion events with the Insights API, and fetches related items or frequently-bought-together results from the Recommend API for a given objectID. Because Recommend models train on Insights events, the two are used together: no events means no recommendations. The agent returns a carousel grounded in real interactions rather than static rules.

Example prompt: Send purchase events through Insights for a set of orders, then request the frequently-bought-together model from Recommend for a product objectID and return five items.

### Run a relevance experiment with a health check

Test a ranking change against live traffic safely. The agent checks cluster status with the Monitoring API before starting, creates an A/B test with the A/B Testing API that pits the production index against a variant, and reads click and conversion deltas from the events the Insights API records per variant. If a guardrail is breached the agent stops the test. The experiment stays measurable and bounded.

Example prompt: Confirm all clusters are operational through Monitoring, create an A/B test between the products index and a variant, and after a set period read the test result and stop it.

## Why Jentic

- **Setup:** Wiring Algolia by hand means learning its application id and API key headers, the different per-service hosts, and the Crawler's separate basic-auth pair. Through Jentic you install once, import the Algolia APIs from the API Directory, store your credentials once, and your agent calls them.
- **Permission scoping:** Many Algolia endpoints put the index name in the URL path, so a rule can pin your agent to one index and the operations you allow, such as querying but not deleting records. Event ingestion and multi-index queries carry their targets in the request body, so for those a rule bounds which operations the agent may call and you set the rest through the API key's ACL.
- **Credential handling:** Your Algolia application key, and the Crawler's separate pair, are stored encrypted by your own Jentic One instance and injected at execution time. They never enter the agent's prompt, logs, or context.
- **Discovery method:** An agent searches by intent, for example 'send a conversion event to Algolia', and Jentic returns the matching operation from across the nine Algolia APIs with its input schema, so the agent calls the right API without knowing which one it is.

## Related vendors

- **Elastic** — Self-managed search and analytics engine; an alternative when you want to run the search cluster yourself rather than use a hosted service.
- **Meilisearch** — Lightweight open-source search API; a simpler alternative for instant search without the recommendation and personalization layers.
- **Swiftype** — Hosted site-search API with search and autocomplete; a lighter alternative for adding search to a website without the recommendation and personalization services.

## FAQ

### Can AI agents use Algolia APIs?

Yes. All nine Algolia APIs have OpenAPI specifications in the Jentic API Directory, so an agent can discover and call them by intent. Through Jentic the agent searches for an operation, loads its schema, and executes it. Install Jentic One (self-hosted) from its GitHub repo to get started.

### Is there an Algolia MCP server?

You do not need an MCP server to give your agent Algolia. Jentic connects the Algolia APIs directly from the API Directory: import the ones you need, store your application key once, and your agent can index, search, and track events without loading another server's tool definitions into its context.

### Do I need a separate key for each Algolia API?

For most of them, no. One Algolia application id and an API key work across the Search, Ingestion, Monitoring, Query Suggestions, A/B Testing, Recommend, Personalization, and Insights APIs, and you scope what a key can reach through its ACL. The Crawler API is the exception: it uses its own separate credential pair. Through Jentic each credential is stored encrypted and injected at execution time, so it never enters the agent's context.

### Can I limit what my agent is allowed to do with Algolia?

Yes. You choose which operations the agent may call through Jentic, and many Algolia endpoints put the index name in the URL path, so a rule can pin the agent to one index and the operations you pick. You also set the API key's ACL and index restrictions on Algolia's side, so a search-only key cannot write records.

### How do I connect my agent to Algolia?

Install Jentic One on your own infrastructure from its GitHub repo, register your Algolia application id and key with it once, and add the Algolia APIs from the Jentic API Directory. Your agent then searches by intent, for example 'run an Algolia query', and Jentic returns the matching operation with its input schema.

### Do Recommend and Personalization work without event tracking?

No. Both the Recommend and Personalization services train on the click and conversion events you send through the Insights API, so you capture events first and the models build from them. An agent that wants recommendations sends Insights events as part of the same workflow.

### What can I build by combining Algolia APIs?

A common pattern is a full loop: ingest records with the Ingestion API or the Crawler API, query them with the Search API, capture clicks and conversions with the Insights API, and serve recommendations or personalized results from those events. One application ties the indices together, so a workflow moves across the services without re-wiring.