UI libraries / React InstantSearch / Widgets

insights

This is the React InstantSearch v7 documentation. React InstantSearch v7 is the latest version of React InstantSearch and the stable version of React InstantSearch Hooks.

If you were using React InstantSearch v6, you can upgrade to v7.

If you were using React InstantSearch Hooks, you can still use the React InstantSearch v7 documentation, but you should check the upgrade guide for necessary changes.

If you want to keep using React InstantSearch v6, you can find the archived documentation.

Signature 
const middleware = createInsightsMiddleware({
  // Optional parameters
  insightsClient: InsightsClient | null,
  insightsInitParams: object,
  onEvent: function,
})
Import
Copy 
1

import { createInsightsMiddleware } from 'instantsearch.js/es/middlewares';
See code examples

About this middleware

You can use the insights option instead of setting up the Insights middleware yourself.

The createInsightsMiddleware creates an insights middleware to help you achieve the following:

  1. Set the userToken for insights purposes (Click Analytics, Personalization, etc.)
  2. Automatically send events from built-in widgets. You can turn this off if needed
  3. Send events from your own custom widgets

Requirements

Guide Send click and conversion events with React InstantSearch

Examples

Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

import { createInsightsMiddleware } from 'instantsearch.js/es/middlewares';
import { useInstantSearch } from 'react-instantsearch';
import { useLayoutEffect } from 'react';
import algoliasearch from 'algoliasearch/lite'; 

function InsightsMiddleware() {
  const { addMiddlewares } = useInstantSearch();

  useLayoutEffect(() => {
    const middleware = createInsightsMiddleware({
      insightsClient: window.aa,
    });

    return addMiddlewares(middleware);
  }, [addMiddlewares]);

  return null;
}

const searchClient = algoliasearch('YourApplicationID', 'YourSearchOnlyAPIKey');

function App() {
  return (
    <InstantSearch indexName="instant_search" searchClient={searchClient}>
      {/* ... */}
      <InsightsMiddleware />
    </InstantSearch>
  );
}

Options

Parameter Description
insightsClient
type: InsightsClient | null
Optional

The Insights client is used to send events. It synchronizes the user token between search and analytics calls.

To disable userToken synchronization and automatic event sending, set this to null.
Copy 
1
2
3
4
5
6
7
8
9

const middleware = createInsightsMiddleware({
  insightsClient: aa,
});

const userToken = // Get the user token (synchronously or asynchronously).

// The `insights` middleware receives a notification
// and attaches the `userToken` to search calls onwards.
aa('setUserToken', userToken);
insightsInitParams
type: object
Optional

Insights parameters to forward to the Insights client’s init method.

With search-insights >= v1.7.0 and < 2.0.0, the Insights client accepts useCookie and userToken parameters in the init method. You can pass useCookie: false to prevent the usage of cookies to store an anonymous userToken. You can also pass a custom userToken while creating insights middleware, if you have one.

With search-insights >= 2.0.0, the default value of useCookie is false.
Copy 
1
2
3
4
5
6

createInsightsMiddleware({
  insightsClient: window.aa,
  insightsInitParams: {
    useCookie: false,
  }
});
onEvent
type: (event: InsightsEvent, aa: null | InsightsClient) => void
default: undefined
Optional

By default, the middleware sends events to Algolia using the provided insightsClient. You can also control events and send them yourself by implementing an onEvent method for the middleware to call instead. This method lets you access data and filter or modify the payload. You can also use it to send events to third-party trackers.

If you want to use onEvent to send events to third-party trackers, but don’t want to send them to Algolia, you can set insightsClient to null, and you don’t need the search-insights library in your application.

The event parameter has the following properties:

  • insightsMethod?: string: The Insights method (for example, 'viewedObjectIDs', 'clickedObjectIDsAfterSearch'). You can find more in the Insights API reference.
  • payload: { [key: string]: any }: The event payload.
  • widgetType: string: The widget type given by connectors (for example, 'ais.refinementList', 'ais.hits')
  • eventType: string: The event type (for example, 'view', 'click', 'conversion', or anything else if you customized it).
Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

createInsightsMiddleware({
  insightsClient: window.aa,
  onEvent: (event, aa) => {
    const { insightsMethod, payload, widgetType, eventType } = event;

    // Send the event to Algolia
    if (insightsMethod) {
      aa(insightsMethod, payload);
    }

    // Send the event to a third-party tracker
    if (widgetType === 'ais.hits' && eventType === 'click') {
      thirdPartyTracker.send('Product Clicked', payload);
    }
  }
});

Custom events

Parameter Description
Connectors

Many of the InstantSearch connectors expose the sendEvent method. If you use these connectors to create custom widgets, you can leverage the method to send custom events.

Here’s a list of connectors that expose sendEvent and they’re exposed at the default slot of corresponding React InstantSearch components.
Copy 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

function Hits() {
  const { hits, sendEvent } = useHits();

  return (
    <ol>
      {hits.map((hit) => (
        <li key={hit.objectID}>
          <p>{hit.name}</p>
          <button
            type="button"
            onClick={() => sendEvent('click', hit, 'Item Starred')}
          >
            Star
          </button>

          <button
            type="button"
            onClick={() => sendEvent('conversion', hit, 'Item Ordered')}
          >
            Order
          </button>
        </li>
      ))}
    </ol>
  );
}
Did you find this page helpful?
React InstantSearch v7