Prevent typosquatting

Algolia and other search engines prefer exact matches. Sometimes, this is used to take advantage of people’s typing mistakes and get ranked high on a popular search query. For example, consider Twitter users. An example of typosquatting is the account @BarakObama, which has 15,800 followers, but isn’t @BarackObama (Barack Obama’s official account). Because Algolia prioritizes exact matches, typing “BarakObama” would return the “BarakObama” record first, regardless of custom ranking. Not all use cases need to prevent typosquatting. However, if this is your case, which often happens when you have to deal with user-generated content, you may need to put a strategy in place.

Dataset example

Back to the Twitter example: assume you have an index called twitter_accounts that looks like this:

JSON

[
  {
    "twitter_handle": "BarackObama",
    "nb_followers": 103500000
  },
  {
    "twitter_handle": "BarakObama",
    "nb_followers": 15800
  }
]

Even if you set descending custom ranking on nb_followers, because Algolia prioritizes exact results, the @BarakObama account would benefit from the traffic coming from users making a typo when searching for the official Barack Obama account. You can short-circuit this issue with Algolia’s sort-by-attribute feature.

Update the dataset

The recommended solution is to add a boolean attributes that separates popular records from the rest. For example, you could add something like is_verified_account = true, or is_popular = true, and sort on that attribute.

For this approach to work well, the number of records with is_popular or is_verified_account set to true should be a small subset of the dataset (up to 1% of the dataset).

You have a popularity metric (nb_followers), so you can use it to define a rule that determines if a record is popular or not. In this example, you could say that a user is popular if they have more than a million followers. To run the code examples on this page, install the latest API client. You can use the browse method to update the index:

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 SavePopularRecords
{
  class Record
  {
    public int NbFollowers { get; set; }
    public required string TwitterHandle { get; set; }
    public bool IsPopular { get; set; }
  }

  async Task Main(string[] args)
  {
    var client = new SearchClient(new SearchConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY"));

    var hits = await client.BrowseObjectsAsync<Record>(
      "INDEX_NAME",
      new BrowseParamsObject()
    );

    var records = hits.Select(hit => new Record
      {
        TwitterHandle = hit.TwitterHandle,
        NbFollowers = hit.NbFollowers,
        IsPopular = hit.NbFollowers >= 1_000_000,
      })
      .ToList();

    await client.SaveObjectsAsync("INDEX_NAME", records);
  }
}

import 'package:algolia_client_search/algolia_client_search.dart';

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

  final List<Map<String, dynamic>> records = [];

  BrowseResponse? browseResponse;
  do {
    final browseParams =
        BrowseParamsObject(hitsPerPage: 1000, cursor: browseResponse?.cursor);
    browseResponse =
        await client.browse(indexName: "indexName", browseParams: browseParams);
    for (final hit in browseResponse.hits) {
      final props = hit.toJson();
      final isPopular = props['nbFollowers'] > 1000;
      final updatedProduct = {
        ...props,
        'isPopular': isPopular,
      };
      records.add(updatedProduct);
    }
  } while (browseResponse.cursor != null);

  final batchParams = BatchWriteParams(
      requests: records
          .map((record) => BatchRequest(
                action: Action.addObject,
                body: record,
              ))
          .toList());
  await client.batch(
    indexName: "INDEX_NAME",
    batchWriteParams: batchParams,
  );
}

package main

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

func savePopularRecords() {
	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)
	}

	records := []map[string]any{{ /* Your records */ }}

	err = client.BrowseObjects("INDEX_NAME", search.BrowseParamsObject{}, search.WithAggregator(func(res any, err error) {
		if err != nil {
			panic(err)
		}

		browseRes, ok := res.(search.BrowseResponse)
		if !ok {
			panic("Invalid response")
		}

		for _, hit := range browseRes.Hits {
			record := hit.AdditionalProperties
			record["isPopular"] = record["nbFollowers"].(int) >= 1_000_000

			records = append(records, record)
		}
	}))
	if err != nil {
		panic(err)
	}

	_, err = client.SaveObjects(
		"INDEX_NAME", records)
	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.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class savePopularRecords {

  public static void main(String[] args) throws Exception {
    try (SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")) {
      List<Map<String, Object>> records = new ArrayList<>();

      client.browseObjects("INDEX_NAME", Hit.class).forEach(hit -> {
        Map<String, Object> props = hit.getAdditionalProperties();
        int nbFollowers = (int) props.get("nbFollowers");

        Map<String, Object> record = new HashMap<>();
        record.put("twitterHandle", props.get("twitterHandle"));
        record.put("nbFollowers", nbFollowers);
        record.put("isPopular", nbFollowers >= 1_000_000);

        records.add(record);
      });

      client.saveObjects("INDEX_NAME", records);
    } catch (Exception e) {
      System.out.println("An error occurred: " + e.getMessage());
    }
  }
}

import { algoliasearch } from 'algoliasearch';

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

const records: Array<Record<string, any>> = [];

await client.browseObjects<Record<string, any>>({
  indexName: 'INDEX_NAME',
  browseParams: undefined,
  aggregator: (res) =>
    records.push(
      res.hits.map((record) => ({
        ...record,
        isPopular: record.nbFollowers >= 1_000_000,
      })),
    ),
});

await client.saveObjects({ indexName: 'indexName', objects: records });

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.*
import kotlinx.serialization.json.JsonObject
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.buildJsonObject

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

  var records: List<JsonObject> = listOf()

  client.browseObjects(
    "INDEX_NAME",
    BrowseParamsObject(),
    aggregator = { response ->
      records =
        records +
          response.hits.map { hit ->
            val props = hit.additionalProperties ?: mapOf()

            val nbFollowers = props["nbFollowers"].toString().toInt()

            buildJsonObject {
              put("twitterHandle", JsonPrimitive(props["twitterHandle"].toString()))
              put("nbFollowers", JsonPrimitive(nbFollowers))
              put("isPopular", JsonPrimitive(nbFollowers > 1000000))
            }
          }
    },
  )
  client.saveObjects(indexName = "INDEX_NAME", objects = records)
}

<?php

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

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

$results = $client->browseObjects('INDEX_NAME');

$records = [];
foreach ($results as $hit) {
    $records[] = [
        'twitterHandle' => $hit['twitterHandle'],
        'nbFollowers' => $hit['nbFollowers'],
        'isPopular' => $hit['nbFollowers'] > 1000000,
    ];
}

$client->saveObjects(
    'INDEX_NAME',
    $records,
);

from algoliasearch.search.client import SearchClientSync

from algoliasearch.search.models.browse_response import BrowseResponse


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


records = []


def _aggregator(resp: BrowseResponse):
    for hit in resp.hits:
        hit_dict = hit.to_dict()
        records.append(
            {
                "twitterHandle": hit_dict["twitterHandle"],
                "nbFollowers": hit_dict["nbFollowers"],
                "isPopular": hit_dict["nbFollowers"] > 1000000,
            }
        )


_client.browse_objects(
    index_name="INDEX_NAME",
    aggregator=_aggregator,
)

_client.save_objects(
    index_name="INDEX_NAME",
    objects=records,
)

require "algolia"

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

records = []

client.browse_objects(
  index_name = "INDEX_NAME"
) do |resp|
  resp.hits.each { |hit|
    record = hit
    record["isPopular"] = hit["nbFollowers"] > 1000000
    records.append(record)
  }
end

client.save_objects("INDEX_NAME", records)

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global

import algoliasearch.api.SearchClient
import algoliasearch.config.*
import algoliasearch.extension.SearchClientExtensions
import algoliasearch.search.{BrowseParamsObject, BrowseResponse}

case class Record(
    twitterHandle: String,
    nbFollowers: Int,
    isPopular: Boolean
)

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

  var records: Seq[Record] = Seq.empty

  client
    .browseObjects(
      "INDEX_NAME",
      BrowseParamsObject(),
      aggregator = (response: BrowseResponse) => {
        records = records ++ response.hits.map { hit =>
          val props = hit.additionalProperties.getOrElse(List()).toMap

          var nbFollowers = props("nbFollowers").toString.toInt

          Record(
            twitterHandle = props("twitterHandle").toString,
            nbFollowers = nbFollowers,
            isPopular = nbFollowers > 1000000
          )
        }
      }
    )
    .flatMap { _ =>
      client.saveObjects(
        indexName = "INDEX_NAME",
        objects = records
      )

      Future.unit
    }
    .recover { case ex: Exception =>
      println(s"An error occurred: ${ex.getMessage}")
    }
}

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

import AlgoliaCore
import AlgoliaSearch

struct Record: Codable {
    let twitterHandle: String
    let nbFollowers: Int
    var isPopular = false
}

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

    var records: [Record] = []

    try await client.browseObjects(
        indexName: "INDEX_NAME",
        browseParams: BrowseParamsObject(),
        aggregator: { (response: BrowseResponse<Record>) in
            records.append(contentsOf: response.hits.map {
                $0.nbFollowers < 1_000_000 ? $0 : Record(
                    twitterHandle: $0.twitterHandle,
                    nbFollowers: $0.nbFollowers,
                    isPopular: true
                )
            })
        }
    )

    try await client.saveObjects(indexName: "INDEX_NAME", objects: records)
}

After the update, your dataset would look like this:

JSON

[
  {
    "twitter_handle": "BarackObama",
    "nb_followers": 103500000,
    "is_popular": true
  },
  {
    "twitter_handle": "BarakObama",
    "nb_followers": 15800,
    "is_popular": false
  }
]

By default, Typo is the first criterion in Algolia’s ranking formula which, for most use cases, is sensible. To prevent typosquatting, you need to add another ranking signal that’s higher than the typo rule—the sort-by attribute. When your ranking has been applied, searching for “BarakObama” returns the “BarackObama” record first.

Add a sort-by attribute in the dashboard

Go to the Algolia dashboard and select your Algolia .
On the left sidebar, select Search.
Select your Algolia index.
On the Configuration tab, select Ranking and Sorting.
Click Add sort-by attribute and type or select your attributes.
Save your changes.

Add a sort-by attribute with the API

To set a sort-by attribute, you need to use the ranking with the setSettings method.

var response = await client.SetSettingsAsync(
  "INDEX_NAME",
  new IndexSettings
  {
    Ranking = new List<string>
    {
      "desc(is_popular)",
      "typo",
      "geo",
      "words",
      "filters",
      "proximity",
      "attribute",
      "exact",
      "custom",
    },
  }
);

final response = await client.setSettings(
  indexName: "INDEX_NAME",
  indexSettings: IndexSettings(
    ranking: [
      "desc(is_popular)",
      "typo",
      "geo",
      "words",
      "filters",
      "proximity",
      "attribute",
      "exact",
      "custom",
    ],
  ),
);

response, err := client.SetSettings(client.NewApiSetSettingsRequest(
  "INDEX_NAME",
  search.NewEmptyIndexSettings().SetRanking(
    []string{"desc(is_popular)", "typo", "geo", "words", "filters", "proximity", "attribute", "exact", "custom"})))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.setSettings(
  "INDEX_NAME",
  new IndexSettings().setRanking(
    Arrays.asList("desc(is_popular)", "typo", "geo", "words", "filters", "proximity", "attribute", "exact", "custom")
  )
);

const response = await client.setSettings({
  indexName: 'theIndexName',
  indexSettings: {
    ranking: ['desc(is_popular)', 'typo', 'geo', 'words', 'filters', 'proximity', 'attribute', 'exact', 'custom'],
  },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings =
      IndexSettings(
        ranking =
          listOf(
            "desc(is_popular)",
            "typo",
            "geo",
            "words",
            "filters",
            "proximity",
            "attribute",
            "exact",
            "custom",
          )
      ),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['ranking' => [
        'desc(is_popular)',

        'typo',

        'geo',

        'words',

        'filters',

        'proximity',

        'attribute',

        'exact',

        'custom',
    ],
    ],
);

response = client.set_settings(
    index_name="INDEX_NAME",
    index_settings={
        "ranking": [
            "desc(is_popular)",
            "typo",
            "geo",
            "words",
            "filters",
            "proximity",
            "attribute",
            "exact",
            "custom",
        ],
    },
)

response = client.set_settings(
  "INDEX_NAME",
  Algolia::Search::IndexSettings.new(
    ranking: ["desc(is_popular)", "typo", "geo", "words", "filters", "proximity", "attribute", "exact", "custom"]
  )
)

val response = Await.result(
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(
      ranking = Some(
        Seq("desc(is_popular)", "typo", "geo", "words", "filters", "proximity", "attribute", "exact", "custom")
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.setSettings(
    indexName: "INDEX_NAME",
    indexSettings: IndexSettings(ranking: [
        "desc(is_popular)",
        "typo",
        "geo",
        "words",
        "filters",
        "proximity",
        "attribute",
        "exact",
        "custom",
    ])
)

Search and Discovery platform

Optimization and Personalization

AI-powered experiences

Production and scale

Prevent typosquatting

Dataset example

Update the dataset

Add a sort-by attribute in the dashboard

Add a sort-by attribute with the API

​Dataset example

​Update the dataset

​Add a sort-by attribute in the dashboard

​Add a sort-by attribute with the API

Dataset example

Update the dataset

Add a sort-by attribute in the dashboard

Add a sort-by attribute with the API