Search by SKU

Business-to-business (B2B) buyers often search with exact product identifiers, such as stock keeping units (SKUs), part numbers, or their own references. This guide shows how to configure Algolia so that these searches match precisely.

Turn off typo tolerance for SKUs

Store SKUs and other product identifiers as strings, and make those attributes searchable. By default, Algolia enables typo tolerance for numeric search terms. That’s helpful when you don’t need numbers to match exactly, for example, when searching for product variants or physical sizes. To prevent typo matches in SKUs, add your SKU attribute to disableTypoToleranceOnAttributes. This turns off typo tolerance for the SKU attribute. Products can still match a SKU prefix or another searchable attribute. For example, searching for 123 can match 123456.

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings { DisableTypoToleranceOnAttributes = new List<string> { "serial_number" } }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    disableTypoToleranceOnAttributes: [
      "serial_number",
    ],
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetDisableTypoToleranceOnAttributes(
    []string{"serial_number"})))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings(
  "INDEX_NAME",
  new IndexSettings().setDisableTypoToleranceOnAttributes(Arrays.asList("serial_number"))
);

const response = await client.setSettings({
  indexName: 'theIndexName',
  indexSettings: { disableTypoToleranceOnAttributes: ['serial_number'] },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(disableTypoToleranceOnAttributes = listOf("serial_number")),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['disableTypoToleranceOnAttributes' => [
        'serial_number',
    ],
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "disableTypoToleranceOnAttributes": [
            "serial_number",
        ],
    },
)

response = client.set_settings(
  "INDEX_NAME",
  Algolia::Search::IndexSettings.new(disable_typo_tolerance_on_attributes: ["serial_number"])
)

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      disableTypoToleranceOnAttributes = Some(Seq("serial_number"))
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(disableTypoToleranceOnAttributes: ["serial_number"])
)

Search in hyphenated attributes

By default, Algolia regards hyphens as separators, so that searching for 123-X-456 and 123 X 456 returns the same results. To support searches for numbers without spaces, for example, 123X456, index that format alongside 123-X-456. For more information, see Include all possible formats.

Detect search intent with Rules

Use Algolia Rules to detect keywords in a and adjust the search. For example, remove “article” from a query and restrict the search to selected attributes. For more information, see:

Search by custom product aliases

B2B buyers often return to buy the same products. Typing or copying SKUs or other lengthy product identifiers every time can be tedious and error-prone. Some ecommerce platforms allow buyers to save a custom alias, or reference, for an item. Use Algolia Rules to let buyers search by their custom aliases. For example, a buyer saves my_product as an alias for the SKU 123-456-789. If a search contains my_product and includes user_123 in ruleContexts, the rule replaces the alias with the SKU in the search query.

JavaScript

const rule = {
  objectID: 'user_123_alias_1',
  conditions: [
    {
      pattern: 'my_product',
      anchoring: 'contains',
      context: 'user_123'
    }
  ],
  consequence: {
    params: {
      query: {
        edits: [
          {
            type: 'replace',
            delete: 'my_product',
            insert: '123-456-789',
          },
        ],
      },
    },
  },
}

To apply this buyer’s rule, include user_123 in the ruleContexts parameter when searching with an API client:

namespace Algolia;

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Text.Json;
using Algolia.Search.Clients;
using Algolia.Search.Http;
using Algolia.Search.Models.Search;

class SearchWithRuleContextBuyer
{
  private static string GetBuyerAccountId()
  {
    return ""; // Implement your logic here
  }

  async Task Main(string[] args)
  {
    var client = new SearchClient(new SearchConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY"));
    // get the buyer account information
    var buyer = GetBuyerAccountId();
    var searchParams = new SearchParams(
      new SearchParamsObject { Query = "SEARCH_QUERY", RuleContexts = [buyer] }
    );

    await client.SearchSingleIndexAsync<Hit>("INDEX_NAME", searchParams);
  }
}

import 'package:algolia_client_search/algolia_client_search.dart';

String getBuyerAccountId() {
  return ""; // Implement your logic here
}

void searchWithRuleContextBuyer() async {
  final client =
      SearchClient(appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

  // get the buyer account information
  final buyer = getBuyerAccountId();
  final searchParams =
      SearchParamsObject(query: "SEARCH_QUERY", ruleContexts: [buyer]);

  await client.searchSingleIndex(
    indexName: "INDEX_NAME",
    searchParams: searchParams,
  );
}

package main

import (
	"github.com/algolia/algoliasearch-client-go/v4/algolia/search"
)

func getBuyerAccountID() (string, error) {
	return "", nil // Implement your logic here
}

func searchWithRuleContextBuyer() {
	client, err := search.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
	if err != nil {
		// The client can fail to initialize if you pass an invalid parameter.
		panic(err)
	}

	// get the buyer account information
	buyer, err := getBuyerAccountID()
	if err != nil {
		panic(err)
	}

	searchParams := search.SearchParamsObjectAsSearchParams(
		search.NewSearchParamsObject().
			SetQuery("SEARCH_QUERY").
			SetRuleContexts([]string{buyer}),
	)

	_, err = client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
		"INDEX_NAME").WithSearchParams(searchParams))
	if err != nil {
		panic(err)
	}
}

package com.algolia;

import com.algolia.api.SearchClient;
import com.algolia.config.*;
import com.algolia.model.search.*;
import java.util.List;

public class searchWithRuleContextBuyer {

  private static String getBuyerAccountId() {
    return ""; // Implement your logic here
  }

  public static void main(String[] args) throws Exception {
    try (SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")) {
      // get the buyer account information
      String buyer = getBuyerAccountId();
      SearchParams searchParams = new SearchParamsObject().setQuery("SEARCH_QUERY").setRuleContexts(List.of(buyer));

      client.searchSingleIndex("INDEX_NAME", searchParams, Hit.class);
    } catch (Exception e) {
      System.out.println("An error occurred: " + e.getMessage());
    }
  }
}

import { algoliasearch } from 'algoliasearch';

import type { SearchParams } from 'algoliasearch';

const getBuyerAccountId = () => {
  return ''; // Implement your logic here
};

const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// get the buyer account information
const buyer = getBuyerAccountId();
const searchParams: SearchParams = {
  query: 'SEARCH_QUERY',
  ruleContexts: [buyer],
};

await client.searchSingleIndex({ indexName: 'indexName', searchParams: searchParams });

import com.algolia.client.api.SearchClient
import com.algolia.client.configuration.*
import com.algolia.client.extensions.*
import com.algolia.client.model.search.*
import com.algolia.client.transport.*

val getBuyerAccountId: () -> String = {
  "" // Implement your logic here
}

suspend fun searchWithRuleContextBuyer() {
  val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

  // get the buyer account information
  val buyer = getBuyerAccountId()
  val searchParams = SearchParamsObject(query = "SEARCH_QUERY", ruleContexts = listOf(buyer))

  client.searchSingleIndex(indexName = "INDEX_NAME", searchParams = searchParams)
}

<?php

require __DIR__.'/../vendor/autoload.php';
use Algolia\AlgoliaSearch\Api\SearchClient;
use Algolia\AlgoliaSearch\Model\Search\SearchParamsObject;

$getBuyerAccountId = function (): string {
    // Implement your logic here
    return '';
};

$client = SearchClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// get the buyer account information
$buyer = $getBuyerAccountId();
$searchParams = (new SearchParamsObject())
    ->setQuery('SEARCH_QUERY')
    ->setRuleContexts([$buyer])
;

$client->searchSingleIndex(
    'INDEX_NAME',
    $searchParams,
);

from algoliasearch.search.client import SearchClientSync

from algoliasearch.search.models.search_params import SearchParams


def _get_buyer_account_id() -> str:
    # Implement your logic here
    return ""


_client = SearchClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")


# get the buyer account information
buyer = _get_buyer_account_id()
search_params = SearchParams(
    query="SEARCH_QUERY",
    rule_contexts=[buyer],
)

_client.search_single_index(
    index_name="INDEX_NAME",
    search_params=search_params,
)

require "algolia"

def get_buyer_account_id
  # Implement your logic here
  ""
end

client = Algolia::SearchClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# get the buyer account information
buyer = get_buyer_account_id
search_params = Algolia::Search::SearchParamsObject.new(
  query: "SEARCH_QUERY",
  rule_contexts: [buyer]
)

client.search_single_index("INDEX_NAME", search_params)

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Await
import scala.concurrent.duration.Duration

import algoliasearch.api.SearchClient
import algoliasearch.config.*
import algoliasearch.extension.SearchClientExtensions
import algoliasearch.search.SearchParamsObject

val getBuyerAccountId: () => String = () => {
  "" // Implement your logic here
}

def searchWithRuleContextBuyer(): Future[Unit] = {
  val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

  // get the buyer account information
  val buyer = getBuyerAccountId()
  val searchParams = SearchParamsObject(query = Some("SEARCH_QUERY"), ruleContexts = Some(Seq(buyer)))

  Await.result(
    client
      .searchSingleIndex(
        indexName = "INDEX_NAME",
        searchParams = Some(searchParams)
      )
      .map(_ => Future.unit),
    Duration(5, "sec")
  )
}

import Foundation
#if os(Linux) // For linux interop
    import FoundationNetworking
#endif

import AlgoliaCore
import AlgoliaSearch

let getBuyerAccountId = { "" } // Implement your logic here

func searchWithRuleContextBuyer() async throws {
    let client = try SearchClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

    // get the buyer account information
    let buyer = getBuyerAccountId()
    let searchParams = SearchSearchParams.searchSearchParamsObject(
        SearchSearchParamsObject(query: "SEARCH_QUERY", ruleContexts: [buyer])
    )

    let response: SearchResponse<Hit> = try await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: searchParams
    )
    print(response)
}

For more information, see:

Search and Discovery platform

Optimization and Personalization

AI-powered experiences

Production and scale

Turn off typo tolerance for SKUs

Search in hyphenated attributes

Detect search intent with Rules

Search by custom product aliases

​Turn off typo tolerance for SKUs

​Search in hyphenated attributes

​Detect search intent with Rules

​Search by custom product aliases

Turn off typo tolerance for SKUs

Search in hyphenated attributes

Detect search intent with Rules

Search by custom product aliases