Guides / Sending and managing data / Manage indices and apps / Manage indices

Nov 08, 2023

Delete indices

Indices with replicas

If the index you want to delete is a replica of another index, you must first unlink it.

If the index is a primary index and has replicas, the replica indices will become independent indices if you delete their primary index.

Delete indices in the Algolia dashboard

To delete an index from the dashboard:

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index:
Select Manage index > Delete.
Type DELETE to confirm and click Delete.

Delete indices with the API

To delete an index, use one of these methods:

API clients: deleteIndex
Algolia CLI: algolia indices delete

Copy

1
2
3
4
5
6
7
8
9
10
<?php
require_once __DIR__."/vendor/autoload.php";
use Algolia\AlgoliaSearch\SearchClient;

// Use an API key with `deleteIndex` ACL
$client = SearchClient::create(
  'YourApplicationID', 'YourAPIKey'
);
$index = $client->initIndex('YourIndexName');
$index->delete();

1
2
3
4
5
6
7
8
require 'algolia'

# Use an API key with `deleteIndex` ACL
client = Algolia::Search::Client.create(
  'YourApplicationID', 'YourAPIKey'
)
index = client.init_index('YourIndexName')
index.delete

1
2
3
4
5
6
7
const algoliasearch = require('algoliasearch');

// Use an API key with `deleteIndex` ACL
const client = algoliasearch('YourApplicationID', 'YourAPIKey');
const index = client.initIndex('YourIndexName');

index.delete();

1
2
3
4
5
6
from algoliasearch.search_client import SearchClient

# Use an API key with `deleteIndex` ACL
client = SearchClient.create("YourApplicationID", "YourAPIKey")
index = client.init_index("YourIndexName")
index.delete()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import AlgoliaSearchClient

// Use an API key with `deleteIndex` ACL
let client = SearchClient(
  appID: "YourApplicationID",
  apiKey: "YourAPIKey"
)
let index = client.index(withName: "YourIndexName")

index.delete { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
// Use an API key with `deleteIndex` ACL
val client = ClientSearch(
  ApplicationID("YourApplicationID"),
  APIKey("YourAPIKey")
)
val index = client.initIndex(IndexName("YourIndexName"))

index.deleteIndex()

1
2
3
4
5
6
7
8
// Use an API key with `deleteIndex` ACL
var client = new SearchClient("YourApplicationID", "YourAPIKey");
var index = client.InitIndex("YourIndexName");

index.Delete();

// Asynchronous
await index.DeleteAsync();

1
2
3
4
5
6
7
8
// Use an API key with `deleteIndex` ACL
SearchClient client = DefaultSearchClient.create("YourApplicationID", "YourAPIKey");
SearchIndex<Record> index = client.initIndex("YourIndexName", Record.class);

index.delete();

//Asynchronous
index.deleteAsync();

1
2
3
4
// Use an API key with `deleteIndex` ACL
client := search.NewClient("YourApplicationID", "YourAPIKey")
index := client.InitIndex("YourIndexName")
res, err := index.Delete()

Delete multiple indices

To delete more than one index:

Use listIndices (API client) or algolia indices list (Algolia CLI) to get your indices
Use multipleBatch or algolia indices delete to delete multiple indices with a single request.

To delete replica indices, you must first delete their primary indices.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<?php
require_once __DIR__."/vendor/autoload.php";
use Algolia\AlgoliaSearch\SearchClient;

// You need an API key with `deleteIndex` permissions
$client = SearchClient::create('YourApplicationID', 'YourAPIKey');

// List all indices
$indices = $client->listIndices();

// Primary indices don't have a `primary` key
$primaryIndices = array_filter($indices['items'], function ($index){
    return !isset($index['primary']);
});
$replicaIndices = array_filter($indices['items'], function ($index){
    return isset($index['primary']);
});

// Delete primary indices first
foreach ($primaryIndices as $i) {
  $index = $client->initIndex($i['name']);
  $index->delete()->wait();
}
echo "Deleted primary indices.\n";

// Now, delete replica indices
foreach ($replicaIndices as $i) {
  $index = $client.initIndex($i['name']);
  $index->delete()->wait();
}
echo "Deleted replica indices.\n";

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
require 'algolia'

# You need an API key with `deleteIndex` permissions
client = Algolia::Search::Client.create('YourAppplicationId', 'YourAPIKey')

# List all indices
indices = client.list_indexes

# Primary indices don't have a `primary` key
primaryIndices, replicaIndices = indices[:items].partition { |index| index[:primary].nil? }

# Delete primary indices first
client.multiple_batch(
  primaryIndices.map { |index| { indexName: index[:name], action: 'delete' } }
).wait
puts 'Deleted primary indices.'

# Now, delete replica indices
client.multiple_batch(
  replicaIndices.map { |index| { indexName: index[:name], action: 'delete' } }
)
puts 'Deleted replica indices.'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
const algoliasearch = require("algoliasearch");

// You need an API key with `deleteIndex` permissions
const client = algoliasearch("YourApplicationID", "YourAPIKey");

// Use async/await syntax
(async () => {
  // List all indices
  const indices = await client.listIndices();

  // Primary indices don't have a `primary` key
  const primaryIndices = indices.items.filter((index) => !index.primary);
  const replicaIndices = indices.items.filter((index) => index.primary);

  // Delete primary indices first
  client
    .multipleBatch(
      primaryIndices.map((index) => {
        return { indexName: index.name, action: "delete" };
      })
    )
    .wait();
  console.log("Deleted primary indices.");

  // Now, delete replica indices
  client.multipleBatch(
    replicaIndices.map((index) => {
      return { indexName: index.name, action: "delete" };
    })
  );
  console.log("Deleted replica indices.");
})();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from algoliasearch.search_client import SearchClient

# You need an API key with `deleteIndex` permissions
client = SearchClient.create('YourApplicationID', 'YourAPIKey')

# List all indices
indices = client.list_indices()

primaries = []
replicas = []

for index in indices["items"]:
  action = {"indexName": index["name"], "action": "delete"}

  # Primary indices don't have a `primary` key
  if not "primary" in index : 
    primaries.append(action)
  else:
    replicas.append(action)

# Delete primary indices first
client.multiple_batch(primaries).wait()
print("Deleted primary indices.")

# Now, delete replica indices
client.multiple_batch(replicas)
print("Deleted replica indices.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import AlgoliaSearchClient

// You need an API key with `deleteIndex`
let client = SearchClient(
  appID: "YourApplicationID",
  apiKey: "YourAPIKey"
)

// List all indices
let indices = try client.listIndices()

// Primary indices don't have a `primary` key
let primaryIndices = indices.items.filter { $0.primary == nil }
let replicaIndices = indices.items.filter { $0.primary != nil }

// Delete primary indices first
try! client.multipleBatchObjects(operations: primaryIndices)
print("Deleted primary indices.")

// Now, delete replica indices
try! client.multipleBatchObjects(operations: replicaIndices)
print("Deleted replica indices.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
import com.algolia.search.client.ClientSearch
import com.algolia.search.model.APIKey
import com.algolia.search.model.ApplicationID
import com.algolia.search.model.indexing.BatchOperation
import com.algolia.search.model.multipleindex.BatchOperationIndex

suspend fun main() {
  // You need an API key with `deleteIndex` permission
  val client = ClientSearch(
    applicationID = ApplicationID("YourApplicationID"),
    apiKey = APIKey("YourAPIKey")
  )

  // Primary indices don't have a `primary` key
  val (primaryIndices, replicaIndices) = client.listIndices().items.partition { 
    it.primaryOrNull == null
  }

  // Delete primary indices first
  if (primaryIndices.isNotEmpty()) {
    client.multipleBatchObjects(
      primaryIndices.map { 
        BatchOperationIndex(it.indexName, BatchOperation.DeleteIndex)
      }
    )
    println("Deleted primary indices.")
  }

  // Now, delete replica indices
  if (replicaIndices.isNotEmpty()) {
    client.multipleBatchObjects(
      replicaIndices.map {
        BatchOperationIndex(it.indexName, BatchOperation.DeleteIndex)
      }
    )
    println("Deleted replica indices.")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
using System;
using System.Collections.Generic;
using Algolia.Search.Clients;
using Algolia.Search.Models.Batch;
using Algolia.Search.Models.Enums;

namespace DeleteIndex
{
  class Program
  {
    static void Main(string[] args)
    {
      // You need an API key with `deleteIndex` permissions
      var client = new SearchClient(
          "YourApplicationID",
          "YourAPIKey"
      );

      // List all indices
      var indices = client.ListIndices().Items;
      var primaryIndices = new List<BatchOperation<string>>();
      var replicaIndices = new List<BatchOperation<string>>();

      foreach (var index in indices)
      {
        var action = new BatchOperation<string>
        {
          IndexName = index.Name,
          Action = BatchActionType.Delete
        };
        // Primary indices don't have a `Primary` key
        if (index.Primary == null)
        {
          primaryIndices.Add(action);
        }
        else
        {
          replicaIndices.Add(action);
        }
      }

      // Delete primary indices first
      if (primaryIndices.Count > 0)
      {
        client.MultipleBatch(primaryIndices).Wait();
        Console.WriteLine("Deleted primary indices.");
      }

      // Now, delete replica indices
      if (replicaIndices.Count > 0)
      {
        client.MultipleBatch(replicaIndices);
        Console.WriteLine("Deleted replica indices.");
      }
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
import com.algolia.search.DefaultSearchClient;
import com.algolia.search.SearchClient;
import com.algolia.search.models.indexing.ActionEnum;
import com.algolia.search.models.indexing.BatchOperation;
import com.algolia.search.models.indexing.IndicesResponse;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class Program {
  public static void main(String[] args) {
    // You need an API key with `deleteIndex` permissions
    SearchClient client = DefaultSearchClient.create(
      "YourApplicationID", "YourAPIKey"
    );

    // List indices, primary indices don't have a `primary` key
    Map<Boolean, List<IndicesResponse>> indices = client.listIndices().stream().collect(Collectors.partitioningBy(index -> index.getPrimary() == null));

    List<IndicesResponse> primaryIndices = indices.get(true);
    List<IndicesResponse> replicaIndices = indices.get(false);

    // Delete primary indices first
    if (!primaryIndices.isEmpty()) {
      client.multipleBatch(
        primaryIndices
          .stream()
          .map(index -> new BatchOperation<>(index.getName(), ActionEnum.DELETE))
          .collect(Collectors.toList()));

        System.out.println("Deleted primary indices.");
    }

    // Now, delete replica indices
    if (!replicaIndices.isEmpty()) {
      client.multipleBatch(
        replicaIndices
          .stream()
          .map(index -> new BatchOperation<>(index.getName(), ActionEnum.DELETE))
          .collect(Collectors.toList()));

        System.out.println("Deleted replica indices.");
    }
    System.exit(0);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
package main

import (
  "fmt"

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

func main() {
  // You need an API key with `deleteIndex` permissions
  client := search.NewClient(
    "YourApplicationID",
    "YourAPIKey",
  )

  // List all indices
  indices, _ := client.ListIndices()

  var primaryIndices []search.BatchOperationIndexed
  var replicaIndices []search.BatchOperationIndexed

  for _, index := range indices.Items {
    action := search.BatchOperationIndexed{
      IndexName:      index.Name,
      BatchOperation: search.BatchOperation{Action: search.Delete},
    }
    // Primary indices don't have a `Primary` key
    if index.Primary == "" {
      primaryIndices = append(primaryIndices, action)
    } else {
      replicaIndices = append(replicaIndices, action)
    }
  }

  if len(primaryIndices) > 0 {
    res, err := client.MultipleBatch(primaryIndices)
    if err != nil {
      panic(err)
    }
    res.Wait()
    fmt.Println("Primary indices deleted")
  }

  if len(replicaIndices) > 0 {
    _, err := client.MultipleBatch(replicaIndices)
    if err != nil {
      panic(err)
    }
    fmt.Println("Replica indices deleted")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package org.example

import algolia.AlgoliaClient
import algolia.AlgoliaDsl._
import algolia.responses.Indices

import scala.concurrent.Await
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration
import scala.language.postfixOps

object Program extends App {
  // You need an API key with `deleteIndex` permission
  val client = new AlgoliaClient("YourApplicationID", "YourAPIKey")

  // List all indices
  val indices: Indices = Await.result(
    client.execute(list indices), Duration.Inf
  )

  // Primary indices don't have a `primary` key
  val (primaryIndices, replicaIndices) = indices.items.partition(_.primary == null)

  // Delete primary indices first
  for (i <- primaryIndices.items) {
    Await.result(client.execute(delete index i.name), Duration.Inf)
  }
  println("Deleted primary indices.")

  // Now, delete replica indices
  for (i <- replicaIndices.items) {
    Await.result(client.execute(delete index i.name), Duration.Inf)
  }
  println("Deleted replica indices.")
}

Clear records from an index in the Algolia dashboard

If you only want to delete (clear) the records from an index, keeping the index configuration, follow these steps:

Go to the Algolia dashboard and select your Algolia application.
On the left sidebar, select Search.
Select your Algolia index:
Select Manage index > Clear.
Type CLEAR to confirm and click Clear.

Clear records from an index with the API

To remove only the records from the index, while keeping the settings, synonyms, and rules, use one of the following methods:

API clients: clearObjects
Algolia CLI: algolia indices clear

Copy

1
2
3
4
5
6
7
8
9
10
<?php
require_once __DIR__."/vendor/autoload.php";
use Algolia\AlgoliaSearch\SearchClient;

// You need an API key with `deleteIndex` permissions
$client = SearchClient::create('YourApplicationID', 'YourAPIKey');

$index = $client->initIndex('YourIndexName');
$index->clearObjects();
echo "Deleted records.\n";

1
2
3
4
5
6
7
8
require 'algolia'

# You need an API key with `deleteIndex` permissions
client = Algolia::Search::Client.create('YourAppplicationID', 'YourAPIKey')

index = client.init_index('YourIndexName')
index.clear_objects
puts "Deleted records."

1
2
3
4
5
6
7
8
const algoliasearch = require("algoliasearch");

// You need an API key with `deleteIndex` permissions
const client = algoliasearch("YourApplicationID", "YourAPIKey");

const index = client.initIndex("YourIndexName");
index.clearObjects();
console.log("Deleted records");

1
2
3
4
5
6
7
8
from algoliasearch.search_client import SearchClient

# You need an API key with `deleteIndex` permissions
client = SearchClient.create("YourApplicationID", "YourAPIKey")

index = client.init_index("YourIndexName")
index.clear_objects()
print("Deleted records.")

1
2
3
4
5
6
7
8
9
10
import AlgoliaSearchClient

let client = SearchClient(
  appID: "YourApplicationID",
  apiKey: "YourAPIKey"
)

let index = client.index(withName: "YourIndexName")
try! index.clearObjects()
print("Deleted records.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import com.algolia.search.client.ClientSearch
import com.algolia.search.model.APIKey
import com.algolia.search.model.ApplicationID
import com.algolia.search.model.IndexName

suspend fun main() {
  // You need an API key with `deleteIndices` permission
  val client = ClientSearch(
    applicationID = ApplicationID("YourApplicationID"),
    apiKey = APIKey("YourAPIKey")
  )

  val index = client.initIndex(IndexName("YourIndexName"))
  index.clearObjects()
  println("Deleted records.")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
using System;
using Algolia.Search.Clients;

namespace ClearObjects
{
  class Program
  {
    static void Main(string[] args)
    {
      // You need an API key with `deleteIndex` permissions
      var client = new SearchClient(
          "YourApplicationID",
          "YourAPIKey"
      );

      var index = client.InitIndex("YourIndexName");
      index.ClearObjects();
      Console.WriteLine("Deleted records.");
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import com.algolia.search.DefaultSearchClient;
import com.algolia.search.SearchClient;
import com.algolia.search.SearchIndex;

public class Program {
  public static void main(String[] args) {
    // You need an API key with `deleteIndex` permissions
    SearchClient client = DefaultSearchClient.create(
      "YourApplicationID", "YourAPIKey"
    );

    SearchIndex index = client.initIndex("YourIndexName");
    index.clearObjects();
    System.out.println("Deleted records.");
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
  "fmt"

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

func main() {
  // You need an API key with `deleteIndex` permissions
  client := search.NewClient(
    "YourApplicationID",
    "YourAPIKey",
  )
  index := client.InitIndex("YourIndexName")
  index.ClearObjects()
  fmt.Println("Deleted records.")
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package org.example

import algolia.AlgoliaClient
import algolia.AlgoliaDsl._

import scala.concurrent.Await
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration
import scala.language.postfixOps

object Program extends App {
  // You need an API key with `deleteIndex` permissions
  val client = new AlgoliaClient("YourApplicationID", "YourAPIKey")

  Await.result(
    client.execute(clear index "YourIndexName"), Duration.Inf
  )
  println("Deleted records.")
}

Did you find this page helpful?

Delete indices

On this page

Indices with replicas

Delete indices in the Algolia dashboard

Delete indices with the API

Delete multiple indices

Clear records from an index in the Algolia dashboard

Clear records from an index with the API

On this page