Distinguish users for analytics

1
2
3
4
5
6
7
8
9
10
11
12
13
import instantsearch from 'instantsearch.js';

const search = instantsearch({
  indexName: "YourIndexName",
  searchClient,
  insights: true
})

// Set anonymous user token
window.aa("setUserToken", "anonymous-user-123");

// Set authenticated user token
window.aa("setAuthenticatedUserToken", "authenticated-user-123");

1
2
3
4
5
6
7
8
9
10
11
12
import { InstantSearch } from "react-instantsearch";

<InstantSearch
  indexName="YourIndexName"
  searchClient={searchClient}
  insights={true}
>
  {/* ... */}
</InstantSearch>

// Set your own user token
window.aa("setUserToken", "test-user-123")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<template>
<ais-instant-search
  :index-name="<index-name>"
  :search-client="searchClient"
  :insights="true"
>
  <!-- widgets -->
  </ais-instant-search>
</template>

<script>
// Set your own user token
window.aa("setUserToken", "test-user-123")
</script>

1
2
3
4
<ais-configure
  [searchParameters]="{ userToken: 'test-user-123'}"
>
</ais-configure>

1
2
3
let query = Query()
query.userToken = "test-user-123"
let searcher = HitsSearcher(index: index, query: query)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import { InstantSearch, Configure } from 'react-instantsearch';
import algoliasearch from "algoliasearch/lite";

const appID = "YourApplicationID"
const apiKey = "YourSearchAPIKey"

const searchClient = algoliasearch(appID, apiKey);

const App = () => (
  <InstantSearch
    indexName="YourIndexName"
    searchClient={searchClient}
  >
    <Configure userToken="test-user-123" />
  </InstantSearch>
);

1
index.search('query', { userToken: '123456' })

1
2
3
4
5
index.search('query', {
  userToken: '123456'
}).then(({ hits }) => {
  console.log(hits);
});

1
index.search('query', {'userToken': '123456'})

1
2
3
4
5
6
7
8
let query = Query("query")
  .set(\.userToken, to: "123456")

index.search(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
val query = query("query") {
    userToken = UserToken("123456")
}

index.search(query)

1
2
Query query = new Query("query");
query.UserToken = "123456";

1
Query query = new Query("query").setUserToken("123456")

1
2
3
4
res, err := index.Search(
  "query",
  opt.UserToken("123456"),
)

1
2
3
4
5
6
client.execute {
  search into "myIndex" query Query(
    query = Some("query"),
    userToken = Some("123456")
  )
}

1
2
3
4
5
6
require 'algolia'

config = Algolia::Search::Config.create('YourApplicationID', 'YourSearchOnlyAPIKey')
config.default_headers['X-Algolia-UserToken'] = 'test-user-123'

client = Algolia::Search::Client.create_with_config(config)

1
2
3
4
5
6
7
import algoliasearch from "algoliasearch/lite";

const client = algoliasearch("YourApplicationID", "YourSearchOnlyAPIKey", {
  headers: {
    "X-Algolia-UserToken": "test-user-123"
  }
});

1
2
3
4
5
6
7
from algoliasearch.configs import SearchConfig
from algoliasearch.search_client import SearchClient

config = SearchConfig("YourApplicationID", "YourSearchOnlyAPIKey")
config.headers["X-Algolia-UserToken"] = "test-user-123"

client = SearchClient.create_with_config(config)

1
client.setHeader(withName: "X-Algolia-UserToken", to: "test-user-123")

1
2
3
4
5
6
val configuration = ConfigurationSearch(
    applicationID = ApplicationID("YourApplicationID"),
    apiKey = APIKey("YourSearchOnlyAPIKey"),
    defaultHeaders = mapOf("X-Algolia-UserToken" to "test-user-123")
)
ClientSearch(configuration)

1
2
3
4
5
6
var configuration = new SearchConfig("YourApplicationID", "YourSearchOnlyAPIKey")
{
    DefaultHeaders = new Dictionary<string, string> { { "X-Algolia-UserToken", "test-user-123" } },
};

var client = new SearchClient(configuration);

1
2
3
4
5
6
SearchConfig configuration =
new SearchConfig.Builder("YourApplicationID", "YourSearchOnlyAPIKey")
  .addExtraHeaders("X-Algolia-UserToken", "test-user-123")
  .build();

SearchClient client = DefaultSearchClient.create(configuration);

1
2
3
4
5
6
7
8
9
config := search.Configuration{
  AppID:  "YourApplicationID",
  APIKey: "YourSearchOnlyAPIKey",
  Headers: map[string]string{
    "X-Algolia-UserToken": "test-user-123",
  },
}

client := search.NewClientWithConfig(config)

1
2
3
4
5
6
7
val client = new AlgoliaClient(
  "YourApplicationID",
  "YourSearchOnlyAPIKey",
  customHeader = Map(
    "X-Algolia-UserToken" -> "test-user-123"
  )
)