Install the API clients

using System;
using System.Linq;
using System.Collections.Generic;
using Algolia.Search.Clients;
using Algolia.Search.Models.Search;

namespace HelloAlgolia
{
  // a simple record in your index
  class Record
  {
    public string Name { get; set; }
    public string ObjectID { get; set; }
    public override string ToString()
    {
       return $"Name: {Name}, ObjectID: {ObjectID}";
    }
  }

  class Program
  {
    static void Main(string[] args)
    {
       // Connect and authenticate with your Algolia app
       var client = new SearchClient(
          "ALGOLIA_APPLICATION_ID",
          "ALGOLIA_API_KEY"
       );

       // Create a new index and add a record
       var index = client.InitIndex("test_index");
       var record = new Record{ ObjectID = "1", Name = "test_record" };
       index.SaveObject(record).Wait();

       // Search the index and print the results
       var results = index.Search<Record>(new Query("test_record"));
       Console.WriteLine(results.Hits.ElementAt(0).ToString());
    }
  }
}

// helloAlgolia.go
package main

import (
	"fmt"

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

type Record struct {
	ObjectID string `json:"objectID"`
	Name     string `json:"name"`
}

func main() {
	// Connect and authenticate with your Algolia app
	client := search.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

	// Create a new index and add a record
	index := client.InitIndex("test_index")

	record := Record{
		ObjectID: "1",
		Name:     "test_record",
	}

	resSave, err := index.SaveObject(record)
	if err != nil {
		panic(err)
	}
	resSave.Wait()

	// Search the index and print the results
	results, err := index.Search("test_record")
	if err != nil {
		panic(err)
	}

	var records []Record
	results.UnmarshalHits(&records)
	fmt.Println(records)
}

// File: Record.java
import java.io.Serializable;

public class Record implements Serializable {
   private String name;
   private String objectID;

   public Record() {}

   public Record(String name, String objectID) {
      this.name = name;
      this.objectID = objectID;
   }

   @Override
   public String toString() {
      return String.format("Name: %s, objectID: %s", this.name, this.objectID);
   }
   public String getName() { return name; }
   public void setName(String name) { this.name = name; }
   public String getObjectID() { return objectID; }
   public void setObjectID(String objectID) { this.objectID = objectID; }
}

// File: Program.java
import com.algolia.search.DefaultSearchClient;
import com.algolia.search.SearchClient;
import com.algolia.search.SearchIndex;
import com.algolia.search.models.indexing.Query;
import com.algolia.search.models.indexing.SearchResult;

public class Program {
   public static void main(String[] args) {
      // Connect and authenticate with your Algolia app
      SearchClient client = DefaultSearchClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

      // Create a new index and add a record (using the `Record` class)
      SearchIndex<Record> index = client.initIndex("test_index", Record.class);
      Record record = new Record("test_record", "1");
      index.saveObject(record).waitTask();

      // Search the index and print the results
      SearchResult<Record> results = index.search(new Query("test_record"));
      System.out.println(results.getHits().get(0));
   }
}

// helloAlgolia.mjs
import algoliasearch from "algoliasearch";

const appID = "ALGOLIA_APPLICATION_ID";
const apiKey = "ALGOLIA_API_KEY";

// Connect and authenticate with your Algolia app
const client = algoliasearch(appID, apiKey);

// Create a new index and add a record
const index = client.initIndex("test_index");
const record = { objectID: 1, name: "test_record" };

await index.saveObject(record).wait();

// Search the index for "test" and print the results
const { hits } = await index.search("test");
console.log(JSON.stringify(hits[0]));

import com.algolia.search.client.ClientSearch
import com.algolia.search.helper.deserialize
import com.algolia.search.model.APIKey
import com.algolia.search.model.ApplicationID
import com.algolia.search.model.IndexName
import com.algolia.search.model.ObjectID
import com.algolia.search.model.indexing.Indexable
import com.algolia.search.model.search.Query
import kotlinx.serialization.Serializable

// A simple record for your index
@Serializable
private data class Record(
   val name: String,
   override val objectID: ObjectID
) : Indexable

suspend fun main() {
   // Connect and authenticate with your Algolia app
   val client = ClientSearch(
      applicationID = ApplicationID("undefined"),
      apiKey = APIKey("undefined")
   )

   // Create a new index and add a record (using the `Record` class)
   val index = client.initIndex(indexName = IndexName("test_index"))
   val record = Record("test_record", ObjectID("1"))

   index.run {
      saveObject(Record.serializer(), record).wait()
   }

   // Search the index and print the results
   val response = index.run {
      search(Query("test_record"))
   }
   val results: List<Record> = response.hits.deserialize(Record.serializer())
   println(results[0])
}

<?php
// helloAlgolia.php
require __DIR__."/vendor/autoload.php";
use Algolia\AlgoliaSearch\SearchClient;

// Connect and authenticate with your Algolia app
$client = SearchClient::create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

// Create a new index and add a record
$index = $client->initIndex("test_index");
$record = ["objectID" => 1, "name" => "test_record"];
$index->saveObject($record)->wait();

// Search the index and print the results
$results = $index->search("test_record");
var_dump($results["hits"][0]);

# hello_algolia.py
from algoliasearch.search_client import SearchClient

# Connect and authenticate with your Algolia app
client = SearchClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Create a new index and add a record
index = client.init_index("test_index")
record = {"objectID": 1, "name": "test_record"}
index.save_object(record).wait()

# Search the index and print the results
results = index.search("test_record")
print(results["hits"][0])

# hello_algolia.rb
require "algolia"

# Connect and authenticate with your Algolia app
client = Algolia::Search::Client.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Create a new index and add a record
index = client.init_index("test_index")
record = {:"objectID" => 1, :"name" => "test_record"}
index.save_object(record).wait

# Search the index and print the results
results = index.search("test_record")
puts(results[:hits][0])

package org.example

import algolia.AlgoliaClient
import algolia.AlgoliaDsl._
import algolia.objects.Query

import scala.concurrent.Await._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future
import scala.concurrent.duration.Duration
import scala.util.Success

// A simple record for your index
case class Record(name: String, objectID: String)

object Program extends App {
   // Connect and authenticate with your Algolia app
   val client = new AlgoliaClient("undefined", "undefined")

   // Create a new index and add a record
   val indexing = client.execute(index into "test_index" `object` Record("test_record", "1"))
   ready(indexing, Duration.Inf)

   // Search the index and print the results
   val searchFuture: Future[Seq[Record]] = client
      .execute { search into "test_index" query Query(query = Some("test_record")) }
      .map { search => search.as[Record] }

   searchFuture onComplete {
      case Success(results) => println(results(0))
   }
}

// main.swift
import AlgoliaSearchClient

// A simple record for your index
struct Record: Encodable {
   let objectID: ObjectID
   let name: String
}

// Add the client to the dependencies of your targets
let client = SearchClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")
let index = client.index(withName: "test_index")

 // Create a new index and add a record
let record: Record = .init(objectID: "1", name: "test_record")
let indexing: ()? = try? index.saveObject(record).wait()

 // Search the index and print the results
let results = try index.search(query: "test_record")
print(results.hits[0])

# For example:
dotnet run

go run helloAlgolia.go

Depending on your development environment,
build and run the project.

node helloAlgolia.mjs

Depending on your development environment,
build and run the project.

php helloAlgolia.php

python hello_algolia.py

ruby hello_algolia.rb

sbt run

swift run

Name: test_record, ObjectID: 1

{1 test_record}

Name: test_record, objectID: 1

{
   name: 'test_record',
   objectID: '1',
   _highlightResult: {
    // ...
}

Record(name=foo, objectID=1)

array(3) {
   ["name"]=>
   string(11) "test_record"
   ["objectID"]=>
   string(1) "1"
   ["_highlightResult"]=>
   ... }

{'name': 'test_record', 'objectID': '1', '_highlightResult': ...}

{:name=>"test_record", :objectID=>"1", :_highlightResult=>...}

Record(test_record, 1)

Hit<JSON>(objectID: 1, object: {
  name: "test_record",
  objectID: "1",
}