Browse all synonyms

using Algolia.Search.Clients;
using Algolia.Search.Models.Search;

var appID = "ALGOLIA_APPLICATION_ID";
var apiKey = "ALGOLIA_API_KEY";
var indexName = "ALGOLIA_INDEX_NAME";

var client = new SearchClient(appID, apiKey);

var results = await client.BrowseSynonymsAsync(indexName, new SearchSynonymsParams {});

results.ToList().ForEach(synonym => Console.WriteLine($"  - Synonym: {synonym.ObjectID}"));

package main

import (
	"fmt"
	"log"

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

func main() {
	appID := "ALGOLIA_APPLICATION_ID"
	apiKey := "ALGOLIA_API_KEY"
	indexName := "ALGOLIA_INDEX_NAME"

	client, err := search.NewClient(appID, apiKey)
	if err != nil {
		log.Fatalln(err)
	}

	var synonyms []search.SynonymHit

	err = client.BrowseSynonyms(
		indexName,
		*search.NewEmptySearchSynonymsParams(),
		search.WithAggregator(func(r any, err error) {
			if err != nil {
				log.Fatalf("There was an error: %v", err)
			}

			synonyms = append(synonyms, r.(*search.SearchSynonymsResponse).Hits...)
		}),
	)
	if err != nil {
		log.Fatal(err)
	}

	for _, synonym := range synonyms {
		fmt.Printf("- Synonym: %s\n", synonym.ObjectID)
	}
}

package org.example;

import com.algolia.api.SearchClient;
import com.algolia.model.search.SearchSynonymsParams;
import java.io.IOException;

public class Main {

  public static void main(String[] args) throws IOException {
    var appID = "ALGOLIA_APPLICATION_ID";
    var apiKey = "ALGOLIA_API_KEY";
    var indexName = "ALGOLIA_INDEX_NAME";

    var client = new SearchClient(appID, apiKey);

    var response = client.browseSynonyms(indexName, new SearchSynonymsParams());

    for (var synonym : response) {
      System.out.println("Synonym: " + synonym.getObjectID());
    }

    client.close();
  }
}

import { algoliasearch as searchClient } from "algoliasearch";

const appId = "ALGOLIA_APPLICATION_ID";
const apiKey = "ALGOLIA_API_KEY";
const indexName = "ALGOLIA_INDEX_NAME";

const client = searchClient(appId, apiKey);

let synonyms = [];

await client.browseSynonyms({
  indexName,
  aggregator: (res) => {
    synonyms.push(...res.hits);
  },
});

synonyms.forEach((synonym) => console.log(`- Synonym: ${synonym.objectID}`))

package org.example

import com.algolia.client.api.SearchClient
import com.algolia.client.extensions.browseSynonyms
import com.algolia.client.model.search.SearchSynonymsParams
import com.algolia.client.model.search.SearchSynonymsResponse
import com.algolia.client.model.search.SynonymHit

suspend fun main() {
    val appID = "ALGOLIA_APPLICATION_ID"
    val apiKey = "ALGOLIA_API_KEY"
    val indexName = "ALGOLIA_INDEX_NAME"

    val client = SearchClient(appID, apiKey)

    val synonyms = mutableListOf<SynonymHit>()

    client.browseSynonyms(
        indexName = indexName,
        searchSynonymsParams = SearchSynonymsParams(),
        aggregator = { res: SearchSynonymsResponse -> synonyms.addAll(res.hits) })

    synonyms.forEach { synonym -> println("- Synonym: ${synonym.objectID}") }
}

<?php
ini_set('memory_limit', '512M');

require_once realpath(__DIR__.'/vendor/autoload.php');

use Algolia\AlgoliaSearch\Api\SearchClient;

$appID = 'ALGOLIA_APPLICATION_ID';
$apiKey = 'ALGOLIA_API_KEY';
$indexName = 'ALGOLIA_INDEX_NAME';

$client = SearchClient::create(appId: $appID, apiKey: $apiKey);

$res = $client->browseSynonyms($indexName);

$synonyms = [];
foreach ($res as $synonym) {
    $synonyms[] = $synonym;
}

foreach ($synonyms as $synonym) {
  echo '- Synonym ' . $synonym['objectID'] . "\n";
}

from algoliasearch.search.client import SearchClientSync
from algoliasearch.search.models import SearchSynonymsResponse, SynonymHit

app_id = "ALGOLIA_APPLICATION_ID"
api_key = "ALGOLIA_API_KEY"
index_name = "ALGOLIA_INDEX_NAME"

client = SearchClientSync(app_id, api_key)

synonyms = []

_ = client.browse_synonyms(
    index_name=index_name, aggregator=lambda res: synonyms.extend(res.hits)
)

for synonym in synonyms:
    print(f"- Synonym: {synonym.object_id}")

# frozen_string_literal: true

require "algolia"

app_id = "ALGOLIA_APPLICATION_ID"
api_key = "ALGOLIA_API_KEY"
index_name = "ALGOLIA_INDEX_NAME"

client = Algolia::SearchClient.create(app_id, api_key)

synonyms = client.browse_synonyms(index_name)

synonyms.each { |synonym| puts "- Synonym: #{synonym.algolia_object_id}" }

import Foundation
import Search

let appID = "ALGOLIA_APPLICATION_ID"
let apiKey = "ALGOLIA_API_KEY"
let indexName = "ALGOLIA_INDEX_NAME"

let client = try SearchClient(appID: appID, apiKey: apiKey)

var synonyms: [SynonymHit] = []

func aggregate(resp: SearchSynonymsResponse) {
  synonyms.append(contentsOf: resp.hits)
}

try await client.browseSynonyms(
  indexName: indexName,
  searchSynonymsParams: SearchSynonymsParams(),
  aggregator: aggregate
)

for synonym in synonyms {
  print("- Synonym: \(synonym.objectID)")
}