canonical: https://jentic.com/apis/algolia.com/algolia-ingestion-api

# Algolia Ingestion API

Jentic publishes the only available OpenAPI specification for the Algolia Ingestion API, keeping it validated and agent-ready. The Ingestion API powers Algolia's no-code data connectors, letting you create sources, destinations, and tasks that pull data from external systems into Algolia indices on a schedule. It exposes 61 endpoints for managing authentications, sources, destinations, transformations, tasks, and run observability. Use it to wire up CSV, BigQuery, Shopify, or custom-Docker connectors and to monitor every ingestion run.

## For AI agents

Create and run data connectors that ingest records from external sources into Algolia indices. Manage authentications, sources, destinations, tasks, and transformations programmatically.

## Scope

Does not handle search query execution, recommendations, or analytics events - use the Algolia Search, Recommend, and Insights APIs for those. Use this API for data ingestion connectors only.

## Capabilities

- Register source connectors for CSV, BigQuery, Shopify, and Docker-based integrations via /1/sources
- Create reusable authentication credentials and reference them across sources and destinations via /1/authentications
- Schedule and trigger ingestion tasks that pipe records into Algolia indices via /2/tasks
- Inspect run history and event-level diagnostics for any task via /1/runs and /1/events
- Define JavaScript transformations that reshape records before they reach the destination index via /1/transformations
- Push records directly into an index without building a full source pipeline via /1/push/{indexName}

## Use cases

### Scheduled data warehouse to search index sync

Keep an Algolia index in sync with a BigQuery or Snowflake table by registering the warehouse as a source, defining a destination index, and creating a task that runs on a cron schedule. Transformations let you flatten nested rows and rename fields before they hit the index, and run logs surface any rows that failed validation.

Example prompt: Create a BigQuery source pointing at a products table, create a destination for an algolia index named 'products_prod', then create a daily task linking them and trigger an immediate run

### E-commerce catalog ingestion from Shopify

Wire a Shopify storefront into Algolia in minutes by creating a Shopify source with the storefront's authentication, mapping it to a product destination index, and letting Algolia handle incremental pulls. The Ingestion API tracks each run and exposes per-record events so you can diagnose dropped or transformed rows.

Example prompt: Create a Shopify source with stored authentication ID 'shopify-prod-creds', link it to destination 'shopify-products' and run the resulting task

### Custom HTTP source with JavaScript transformation

When the data lives behind a bespoke API, register a custom HTTP source, attach a JavaScript transformation that reshapes each record, and route the output to an Algolia index. The transformation runs server-side on Algolia, so agents do not need to maintain ETL infrastructure.

Example prompt: Create a transformation that lowercases the title field, attach it to a custom HTTP source, and validate the source before saving

### Agent-driven ingestion automation

An AI agent operating through Jentic can search for ingestion intents, list current tasks, find failures by run status, and trigger reruns without leaving the conversation. Credentials are loaded from your Jentic One instance so the agent never sees raw Algolia API keys.

Example prompt: Search Jentic for 'run an Algolia ingestion task', load the runSource operation schema, and execute it for sourceID 'src_abc123'

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | /1/sources | Create an ingestion source |
| POST | /2/tasks | Create an ingestion task |
| POST | /1/sources/{sourceID}/run | Trigger an immediate run |
| POST | /1/push/{indexName} | Push records directly to an index |
| GET | /1/authentications | List stored authentications |
| POST | /1/transformations | Create a JavaScript transformation |

## Key resources

- **Sources** — Connector definitions that pull data from external systems
- **Destinations** — Target Algolia indices receiving ingested records
- **Tasks** — Scheduled or manual jobs that link a source to a destination
- **Authentications** — Reusable credential records for source and destination systems
- **Transformations** — JavaScript functions applied to records during ingestion
- **Runs and Events** — Execution history and per-record diagnostics for tasks

## Why Jentic

- **Setup:** Wiring the Algolia Ingestion API by hand means sending its API key, resolving the data.{region}.algolia.com host, and wiring sources, tasks, and transformations together yourself. Through Jentic you install once, import the Ingestion API from the API Directory, store the API key once, and your agent calls it.
- **Permission scoping:** The Ingestion API puts the source and index ids in the URL path (/1/sources/{sourceID}/run, /1/push/{indexName}), so a rule can pin your agent to one source or index. You choose the operations it may call, so creating sources or transformations is not included unless you add them.
- **Credential handling:** Your Algolia API key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'run an ingestion source' or 'push records to an index', and Jentic returns the matching Algolia Ingestion operation with its input schema so the agent calls the right endpoint without browsing the reference docs.

## Related APIs

- **Meilisearch API** — Open-source search engine with self-hosted ingestion via direct document POSTs
- **Algolia Search API** — Query the indices that the Ingestion API populates
- **Algolia Monitoring API** — Monitor cluster health while ingestion tasks are running

## FAQ

### Why is there no official OpenAPI spec for the Ingestion API?

Algolia does not publish a standalone OpenAPI specification for the Ingestion API. Jentic generates and maintains this spec so that AI agents and developers can call the Ingestion API via structured tooling. It is validated against the live API and kept up to date. Get started with Jentic One, the self-hosted execution layer.

### What authentication does the Algolia Ingestion API use?

Two API key headers: x-algolia-application-id and x-algolia-api-key. Through Jentic, both keys are stored in your Jentic One instance and injected at execution time, so agent code never sees the raw key values.

### Can I create a Shopify connector with the Ingestion API?

Yes. POST to /1/sources with type 'shopify' and a stored authentication ID, then link it to a destination via /2/tasks. The 61 endpoints cover the full source, destination, task, and run lifecycle.

### What are the rate limits for the Algolia Ingestion API?

The spec does not declare numeric rate limits. Algolia enforces per-application throttling on ingestion runs and surfaces 429 responses with a Retry-After header when limits are hit. Plan for exponential backoff on task runs.

### How do I trigger an ingestion task through Jentic?

Search Jentic with 'run an Algolia ingestion task', load the runSource operation, and execute it with the target sourceID. Jentic returns the run ID so the agent can poll /1/runs/{runID} for status.

### Can I transform records before they reach the index?

Yes. Create a JavaScript transformation via POST /1/transformations and attach it to a source. Algolia runs the transformation server-side on each record, so no external ETL infrastructure is needed.

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

Yes. Because you run Jentic One yourself, your own rules decide which Ingestion API operations and credentials the agent may use. Since the source and index identifiers sit in the URL path, such as /1/sources/{sourceID}/run and /1/push/{indexName}, you can pin the agent to a single source or index. You also choose the exact operations it may call, so creating new sources or transformations stays off limits unless you explicitly grant those.