No native build steps, pod installs, or Android linking required. Pure JavaScript/TypeScript.

Project setup

1. Copy the source/ directory into your project, e.g. as vendor/algolia/.

2. Install dependencies via the commands above, or point your package manager at the copied packages if consuming locally.

3. Configure tsconfig.json paths if importing from the vendor copy:

{
  "compilerOptions": {
    "moduleResolution": "node16",
    "paths": {
      "@algolia/client-common": ["./vendor/algolia/client-common/src"],
      "@algolia/client-search": ["./vendor/algolia/client-search/src"],
      "@algolia/client-abtesting": ["./vendor/algolia/client-abtesting/src"]
    }
  }
}

4. Set environment variables (never hard-code credentials):

ALGOLIA_APP_ID=YOUR_APP_ID
ALGOLIA_API_KEY=YOUR_API_KEY

5. The CJS entry for each package is the built dist/builds/node.cjs (e.g. abtesting/index.js points there). For local source usage, import from src/ TypeScript files directly.

Public API

algoliasearch

import { algoliasearch } from 'algoliasearch';

const client = algoliasearch(appId: string, apiKey: string): AlgoliasearchClient;

The main entry point. Returns a unified client with access to search, recommend, and analytics methods. Use this when you need search and object management together without importing multiple packages.

liteClient

import { liteClient } from 'algoliasearch/lite';

const client = liteClient(appId: string, apiKey: string): LiteClient;

A minimal client with only search and browse operations. Use this in front-end bundles where payload size matters and you do not need write or analytics operations.

abtestingClient (from @algolia/client-abtesting)

import { abtestingClient } from '@algolia/client-abtesting';

const client = abtestingClient(appId: string, apiKey: string, region?: string): AbtestingClient;

Provides full CRUD for A/B tests: addABTests, getABTest, listABTests, deleteABTest, and estimateABTest. Use when building experimentation workflows or dashboards.

Models from abtesting/model/

import type {
  ABTest,
  AddABTestsRequest,
  ABTestResponse,
  ListABTestsResponse,
  EstimateABTestRequest,
  EstimateABTestResponse,
  Variant,
  Status,
} from '@algolia/client-abtesting';

Strongly-typed request/response shapes for all A/B testing operations. Import these to type-check payloads before sending.

Working examples

Scenario - Basic search query

Search an Algolia index with the umbrella client and log the hits.

import { algoliasearch } from 'algoliasearch';

const client = algoliasearch(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!
);

async function searchProducts(query: string) {
  const response = await client.search({
    requests: [{ indexName: 'products', query }],
  });
  const hits = response.results[0].hits;
  console.log(`Found ${hits.length} results for "${query}"`);
  return hits;
}

searchProducts('wireless headphones').catch(console.error);

Scenario - Create and inspect an A/B test

Create an A/B test between two index configurations and retrieve its status.

import { abtestingClient } from '@algolia/client-abtesting';
import type { AddABTestsRequest, ABTestResponse } from '@algolia/client-abtesting';

const client = abtestingClient(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!,
  'us'
);

async function createTest(): Promise<ABTestResponse> {
  const request: AddABTestsRequest = {
    name: 'Ranking experiment v1',
    endAt: '2025-12-31T00:00:00.000Z',
    variants: [
      { index: 'products', trafficPercentage: 60 },
      { index: 'products_reranked', trafficPercentage: 40 },
    ],
  };

  const result = await client.addABTests(request);
  console.log('Created A/B test ID:', result.abTestID);

  const test = await client.getABTest({ id: result.abTestID });
  console.log('Status:', test.status);
  return result;
}

createTest().catch(console.error);

Scenario - List all running A/B tests

Fetch a paginated list of active experiments and filter by status.

import { abtestingClient } from '@algolia/client-abtesting';
import type { ListABTestsResponse, ABTest } from '@algolia/client-abtesting';

const client = abtestingClient(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!,
  'us'
);

async function getRunningTests(): Promise<ABTest[]> {
  const response: ListABTestsResponse = await client.listABTests({
    offset: 0,
    limit: 20,
  });

  const running = (response.abtests ?? []).filter(
    (t) => t.status === 'running'
  );

  running.forEach((t) => {
    console.log(`[${t.abTestID}] ${t.name} — ends ${t.endAt}`);
  });

  return running;
}

getRunningTests().catch(console.error);

Scenario - Send insight events

Record click and conversion events for personalization and analytics.

import { insightsClient } from '@algolia/client-insights';

const client = insightsClient(
  process.env.ALGOLIA_APP_ID!,
  process.env.ALGOLIA_API_KEY!
);

async function trackClick(userToken: string, objectID: string) {
  await client.pushEvents({
    events: [
      {
        eventType: 'click',
        eventName: 'Product Clicked',
        index: 'products',
        userToken,
        objectIDs: [objectID],
        timestamp: Date.now(),
      },
    ],
  });
  console.log('Event sent');
}

trackClick('user-42', 'SKU-9001').catch(console.error);

File walkthrough

• abtesting/ - Self-contained A/B testing package; index.js resolves to the prebuilt Node CJS bundle; model/ contains generated TypeScript interfaces; src/abtestingV3Client.ts is the client implementation; builds/ has platform-specific entry points.
• advanced-personalization/ - Advanced personalization package with the same layout: index.js → CJS bundle, model/ → typed request/response interfaces, src/ → client logic.
• algoliasearch/ - Umbrella package; index.js → dist/node.cjs; re-exports search, recommend, and analytics under one import.
• client-abtesting/ - Source implementation consumed by the abtesting/ build wrapper.
• client-analytics/ - Analytics API client source.
• client-common/ - Auth, retry strategy, request serialization, shared types used by all other clients.
• client-insights/ - Insights event-push client source.
• client-personalization/ - Personalization strategy client source.
• client-query-suggestions/ - Query suggestions configuration client source.
• client-search/ - Full search client: index settings, object CRUD, batch operations.
• composition/ - Experimental composition client aggregating multiple API surfaces.
• ingestion/ - Connector and pipeline management for data ingestion into Algolia.
• logger-console/ - Pluggable logger that writes to console.log/console.error.
• monitoring/ - Cluster health and status monitoring client.
• recommend/ - Recommendations engine client: related products, trending, frequently bought together.
• requester-browser-xhr/ - XHR transport adapter for browser environments.
• requester-fetch/ - Fetch API transport for modern browsers and edge workers.
• requester-node-http/ - Native Node.js transport using http/https modules.
• requester-testing/ - Deterministic mock transport for unit and integration testing.

Common pitfalls and fixes

• Missing dist/ files when importing from the vendor copy: The index.js files resolve to dist/builds/node.cjs; run pnpm build inside each package or import directly from src/ TypeScript files instead.
• Region not specified for regional clients: abtestingClient and advancedPersonalizationClient require an explicit region string ('us' or 'de'); omitting it causes routing errors.
• ESM/CJS interop with bundlers: Use moduleResolution: "node16" or "bundler" in tsconfig.json; older "node" resolution may not find the exports map entries.
• Environment variables undefined at runtime: Ensure ALGOLIA_APP_ID and ALGOLIA_API_KEY are set before the process starts; the clients throw immediately if either is an empty string.
• TypeScript strict null errors on model fields: Many model fields are optional; always guard with ?? [] or optional chaining before iterating (e.g. response.abtests ?? []).
• Wrong transport in edge/serverless environments: requester-node-http uses Node.js http which is unavailable in Cloudflare Workers; use requester-fetch (or the builds/fetch.ts entry) in those environments.

Vibe-coding prompt template

I have the Algolia JavaScript API Client source in `source/` and a usage guide
in `USAGE.md`. The upstream package is `algoliasearch-client-javascript`.

Please integrate this client into my project by following these steps:

1. Read `USAGE.md` completely before writing any code.
2. Install the required npm dependencies listed in `## Required dependencies`.
3. Add the tsconfig `paths` entries from `## Project setup` if I am importing
   from the local `source/` copy.
4. Create a file `src/algolia.ts` that initialises the `algoliasearch` client
   using `ALGOLIA_APP_ID` and `ALGOLIA_API_KEY` environment variables and
   exports the client instance.
5. Add a search helper function typed with the real model types from
   `source/client-search/`.
6. If I need A/B testing, add a second file `src/abtesting.ts` that
   initialises `abtestingClient` and exports `createTest` and `listTests`
   functions using the types from `source/abtesting/model/`.
7. Write a brief Jest test using `source/requester-testing/` as the mock
   transport so no real HTTP calls are made.
8. Show all imports using real exported symbol names from `USAGE.md` only.
9. Do not invent any methods or types not documented in `USAGE.md`.

License and credit

The Algolia JavaScript API Client is released under the MIT License (see source/abtesting/LICENSE and source/advanced-personalization/LICENSE). Source: algoliasearch-client-javascript on GitHub. Upstream npm package: algoliasearch.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

The full install guide and integration prompts unlock after purchase.

Nx Smart Monorepo Build and CI Platform

Automation, Utilities & Developer Tools

Free