Redirect searches to a URL

Search isn’t only about retrieving results. Sometimes, depending on what users search for, you might want to redirect them to a specific page of your website or mobile app. Redirecting searches to a URL helps users in these cases:

Improve user experience and navigation. For example, searching for “help” or “return policy” redirects users to a support page.
Display category pages for related keywords to guarantee a consistent user experience and boost SEO by driving more traffic to category pages. For example, searching for a category keyword, such as, “TV” redirects users directly to the corresponding category page.
Promotional campaigns. For example, searching for a specific artist name or brand redirects users to a landing page created specifically to support a promotional operation.
Crisis management. Provide relevant answers to queries related to sudden events. For example, if you detect that your users suddenly start searching for “masks”, redirect them to a specific landing page.

Algolia lets you create redirects to specific URLs with the Autocomplete redirect plugin or a custom implementation

Algolia out-of-the-box redirect solution

The easiest way to redirect search queries to a URL is by adding a rule with the Visual Editor. The rule adds data to the search response, which you can handle in your frontend. The examples on this page add a redirect for the keyword “help” to a support page. You can discover potential redirects by looking at your search analytics. For example, users searching for “help” and not getting any results.

Using the Visual Editor

In the Algolia dashboard, select your application and index, open Rules, and select New rule > Visual Editor.
Click Set query condition(s), select Contains, enter help, and click Apply.
In Consequences, expand More consequences and select Redirect. Enter the URL for your support page and click Apply.
Click Review and Publish, review the rule, and click Publish.

Using the API

To run the code examples on this page, install the latest API client. To add a rule with the API, use the saveRule method. When adding a rule, you need to define a condition and a consequence. In the consequence, add a search parameters and configure renderingContent using the following template:

JSON

{
  "renderingContent": {
    "redirect": {
      "url": "https://www.algolia.com/support"
    }
  }
}

Handle redirects in your user interface

After adding the rule, you can trigger the redirect in your UI when the renderingContent.redirect property is present in the API response. You have two options:

Using the redirect plugin for the Autocomplete UI library
Implement your own logic

Extend the out-of-the-box approach or create custom redirection

If you want to define your own redirection format, or if you need to add additional attributes to the default redirect rule format, you can create a rule with either editor that returns custom data.

Create a rule for returning custom data

You can set a rule that contains the custom data you need to build your custom redirect. This example redirects users to your support page whenever the contains “help”.

Using the dashboard

You can add this rule from the Algolia dashboard using either the Visual Editor or the Manual Editor.

Visual Editor
Manual Editor

Open Rules and select New rule > Visual Editor.
Click Set query condition(s), select Contains, enter help, and click Apply.
In Consequences, expand More consequences and select Return custom data. Enter { "redirect": "https://www.algolia.com/support" } in Value and click Apply.
Click Review and Publish, review the rule, and click Publish.

Open Rules, select Create your first rule or New rule, and select Manual Editor.
In Condition(s), keep Query selected and enter help.
In Consequence(s), click Add consequence and select Return Custom Data. Enter { "redirect": "https://www.algolia.com/support" } in Value.
Optional: add a description that helps your team distinguish this rule from other rules. Save your changes.

Using the API

To add a rule with the API, use the saveRule method. When setting a rule, you need to define a condition and a consequence.

var response = await client.SaveRuleAsync(
  "INDEX_NAME",
  "redirect-help-rule",
  new Rule
  {
    ObjectID = "redirect-help-rule",
    Conditions = new List<Condition>
    {
      new Condition { Pattern = "help", Anchoring = Enum.Parse<Anchoring>("Contains") },
    },
    Consequence = new Consequence
    {
      UserData = new Dictionary<string, string>
      {
        { "redirect", "https://www.algolia.com/support" },
      },
    },
  }
);

final response = await client.saveRule(
  indexName: "INDEX_NAME",
  objectID: "redirect-help-rule",
  rule: Rule(
    objectID: "redirect-help-rule",
    conditions: [
      Condition(
        pattern: "help",
        anchoring: Anchoring.fromJson("contains"),
      ),
    ],
    consequence: Consequence(
      userData: {
        'redirect': "https://www.algolia.com/support",
      },
    ),
  ),
);

response, err := client.SaveRule(client.NewApiSaveRuleRequest(
  "INDEX_NAME", "redirect-help-rule",
  search.NewEmptyRule().SetObjectID("redirect-help-rule").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("help").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetUserData(map[string]any{"redirect": "https://www.algolia.com/support"}))))
if err != nil {
  // handle the eventual error
  panic(err)
}

UpdatedAtResponse response = client.saveRule(
  "INDEX_NAME",
  "redirect-help-rule",
  new Rule()
    .setObjectID("redirect-help-rule")
    .setConditions(Arrays.asList(new Condition().setPattern("help").setAnchoring(Anchoring.CONTAINS)))
    .setConsequence(
      new Consequence().setUserData(
        new HashMap() {
          {
            put("redirect", "https://www.algolia.com/support");
          }
        }
      )
    )
);

const response = await client.saveRule({
  indexName: 'indexName',
  objectID: 'redirect-help-rule',
  rule: {
    objectID: 'redirect-help-rule',
    conditions: [{ pattern: 'help', anchoring: 'contains' }],
    consequence: { userData: { redirect: 'https://www.algolia.com/support' } },
  },
});

var response =
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "redirect-help-rule",
    rule =
      Rule(
        objectID = "redirect-help-rule",
        conditions =
          listOf(
            Condition(
              pattern = "help",
              anchoring = Anchoring.entries.first { it.value == "contains" },
            )
          ),
        consequence =
          Consequence(
            userData =
              buildJsonObject {
                put("redirect", JsonPrimitive("https://www.algolia.com/support"))
              }
          ),
      ),
  )

$response = $client->saveRule(
    'INDEX_NAME',
    'redirect-help-rule',
    ['objectID' => 'redirect-help-rule',
        'conditions' => [
            ['pattern' => 'help',
                'anchoring' => 'contains',
            ],
        ],
        'consequence' => ['userData' => ['redirect' => 'https://www.algolia.com/support',
        ],
        ],
    ],
);

response = client.save_rule(
    index_name="INDEX_NAME",
    object_id="redirect-help-rule",
    rule={
        "objectID": "redirect-help-rule",
        "conditions": [
            {
                "pattern": "help",
                "anchoring": "contains",
            },
        ],
        "consequence": {
            "userData": {
                "redirect": "https://www.algolia.com/support",
            },
        },
    },
)

response = client.save_rule(
  "INDEX_NAME",
  "redirect-help-rule",
  Algolia::Search::Rule.new(
    algolia_object_id: "redirect-help-rule",
    conditions: [Algolia::Search::Condition.new(pattern: "help", anchoring: "contains")],
    consequence: Algolia::Search::Consequence.new(user_data: {redirect: "https://www.algolia.com/support"})
  )
)

val response = Await.result(
  client.saveRule(
    indexName = "INDEX_NAME",
    objectID = "redirect-help-rule",
    rule = Rule(
      objectID = "redirect-help-rule",
      conditions = Some(
        Seq(
          Condition(
            pattern = Some("help"),
            anchoring = Some(Anchoring.withName("contains"))
          )
        )
      ),
      consequence = Consequence(
        userData = Some(JObject(List(JField("redirect", JString("https://www.algolia.com/support")))))
      )
    )
  ),
  Duration(100, "sec")
)

let response = try await client.saveRule(
    indexName: "INDEX_NAME",
    objectID: "redirect-help-rule",
    rule: Rule(
        objectID: "redirect-help-rule",
        conditions: [SearchCondition(pattern: "help", anchoring: SearchAnchoring.contains)],
        consequence: SearchConsequence(userData: ["redirect": "https://www.algolia.com/support"])
    )
)

Handle redirects in your user interface

After adding the rule, you can trigger the redirect in your UI when the userData property is present in the API response. If you’re using one of the InstantSearch UI libraries, see Redirects in InstantSearch.

Add redirects using a dedicated index

You can set up redirects by creating a separate index with the list of redirects and the queries that trigger them. Whenever a user performs a search, you have to look in two indices: the regular index to search for items, and the redirect index that determines whether users should be redirected. This technique is useful if you can’t use rules, or if you want to use other Algolia Search features with your redirect queries, such as typo tolerance, synonyms, or a .

Dataset

JSON

[
  {
    "url": "https://www.google.com/#q=star+wars",
    "query_terms": ["star wars"]
  },
  {
    "url": "https://www.google.com/#q=star+wars+actors",
    "query_terms": ["george lucas", "luke skywalker"]
  }
]

Each record in this dataset has a url to redirect the queries, and a list of query_terms, that trigger the redirect. For example, the query “star wars” should redirect to https://www.google.com/#q=star+wars.

Download the dataset
To learn how to import the dataset, see Import from the dashboard

Configure the redirect index

To trigger the redirect only if the query exactly matches one of the query terms, add query_terms to the list of attributesForFaceting, so that you can filter on it:

const algoliaClient = algoliasearch("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

const customSearchClient = {
  ...algoliaClient,
  async search(requests) {
    if (requests[0].params.query) {
      const { results } = await algoliaClient.search([
        ...requests,
        {
          indexName: "your_redirect_index_name",
          params: {
            hitsPerPage: 1,
            facetFilters: [`query_terms:${requests[0].params.query}`],
          },
        },
      ]);

      const redirect = results.pop();

      if (redirect.hits.length) {
        window.location.href = redirect.hits[0].url;
      }

      return { results };
    } else {
      return algoliaClient.search(requests);
    }
  },
};

const search = instantsearch({
  indexName: "instant_search",
  searchClient: customSearchClient,
});

const algoliaClient = algoliasearch("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

const customSearchClient = {
  ...algoliaClient,
  async search(requests) {
    if (requests[0].params.query) {
      const { results } = await algoliaClient.search([
        ...requests,
        {
          indexName: "your_redirect_index_name",
          params: {
            hitsPerPage: 1,
            facetFilters: [`query_terms:${requests[0].params.query}`],
          },
        },
      ]);

      const redirect = results.pop();

      if (redirect.hits.length) {
        window.location.href = redirect.hits[0].url;
      }

      return { results };
    } else {
      return algoliaClient.search(requests);
    }
  },
};

const App = () => ({
  /* Widgets */
});

<template>
  <ais-instant-search
    index-name="instant_search"
    :search-client="customSearchClient"
  >
    <!-- Widgets -->
  </ais-instant-search>
</template>

<script>
  import algoliasearch from 'algoliasearch/lite';

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

  const customSearchClient = {
    ...algoliaClient,
    async search(requests) {
      if (requests[0].params.query) {
        const { results } = await algoliaClient.search([
          ...requests,
          {
            indexName: 'your_redirect_index_name',
            params: {
              hitsPerPage: 1,
              facetFilters: [`query_terms:${requests[0].params.query}`],
            },
          },
        ]);

        const redirect = results.pop();

        if (redirect.hits.length) {
          window.location.href = redirect.hits[0].url;
        }

        return { results };
      } else {
        return algoliaClient.search(requests);
      }
    },
  };

  export default {
    data() {
      return {
        customSearchClient,
      };
    },
  };
</script>

Create a custom search client

You need to create a custom search client that simultaneously sends requests to the regular and redirect indices. The request to the redirect index is sent with:

An empty query, so it doesn’t filter with it
A filter on query_terms with the content of the current query, to match only that contain the current query exactly
hitsPerPage=1, as you only need the first record

Whenever a record matches in the redirect index, a redirect is triggered:

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

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

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

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

const response = await client.setSettings({
  indexName: 'INDEX_NAME',
  indexSettings: { attributesForFaceting: ['query_terms'] },
});

var response =
  client.setSettings(
    indexName = "INDEX_NAME",
    indexSettings = IndexSettings(attributesForFaceting = listOf("query_terms")),
  )

$response = $client->setSettings(
    'INDEX_NAME',
    ['attributesForFaceting' => [
        'query_terms',
    ],
    ],
);

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

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

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

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

Search and Discovery platform

Optimization and Personalization

AI-powered experiences

Production and scale

Redirect searches to a URL

Algolia out-of-the-box redirect solution

Using the Visual Editor

Using the API

Handle redirects in your user interface

Extend the out-of-the-box approach or create custom redirection

Create a rule for returning custom data

Using the dashboard

Using the API

Handle redirects in your user interface

Add redirects using a dedicated index

Dataset

Configure the redirect index

Create a custom search client

​Algolia out-of-the-box redirect solution

​Using the Visual Editor

​Using the API

​Handle redirects in your user interface

​Extend the out-of-the-box approach or create custom redirection

​Create a rule for returning custom data

​Using the dashboard

​Using the API

​Handle redirects in your user interface

​Add redirects using a dedicated index

​Dataset

​Configure the redirect index

​Create a custom search client

Algolia out-of-the-box redirect solution

Using the Visual Editor

Using the API

Handle redirects in your user interface

Extend the out-of-the-box approach or create custom redirection

Create a rule for returning custom data

Using the dashboard

Using the API

Handle redirects in your user interface

Add redirects using a dedicated index

Dataset

Configure the redirect index

Create a custom search client