API client / Methods / Manage indices

Jun. 08, 2023

Browse index

Required API Key: any key with the browse ACL

Method signature

$index->browseObjects()

$index->browseObjects([
  // All the following parameters are optional
  'query' => string,
  // + any browseParameters
  // + any requestOptions
])

index.browse_objects(Hash opts = {
  query: String ,
  # any browseParameters
  # any requestOptions
})

index.browseObjects({
  // A `batch` callback function that's called
  // on every batch of hits with the
  // signature: (hits: THit[]) => any
  batch: function
})

index.browseObjects({
  // A `batch` callback function that's called
  // on every batch of hits with the
  // signature: (hits: THit[]) => any
  batch: function,
  // All the following parameters are optional
  query: string,
  // + any browseParameters
  // + any requestOptions
})

index.browse_objects()
index.browse_objects({
    query: string,
    # + any browseParameters
    # + any requestOptions
})

index.browse(
  query: Query,
  requestOptions: RequestOptions? = nil,
  completion: Result<SearchResponse> -> Void
)

// browseParameters can be set on the Query object

suspend fun Index.browseObjects(
     query: Query = Query(),
     requestOptions: RequestOptions? = null
): List<ResponseSearch>

index.Browse(
  new BrowseIndexQuery(String query)

  // All the following parameters are optional
  requestOptions:  RequestOptions
)
// browseParameters can be set on the BrowseIndexQuery object

index.browseObjects(new BrowseIndexQuery(String query))
index.browseObjects(new BrowseIndexQuery(String query), RequestOptions requestOptions)

// browseParameters can be set on the Query object

index.BrowseObjects(
  opt.Query("query": string),
  // + any browseParameters
)

browse index "myIndex" query Query(query = Some(query))
// browseParameters can be set in the Query object

See code examples

We released a new version of the PHP API client in public beta. Read the beta documentation for more information.

About this method # A

Get all records from an index.

You can use the browse method to get records from an index—for example, to export your index as a backup. To export all records, use an empty query.

Use browse instead of search when exporting records from your index, when ranking, or analytics, isn’t important. The Analytics API doesn’t collect data when using browse.

Don’t use this method for building a search UI. Use search instead.

You can’t export your indices from the Algolia dashboard, only your index settings, synonyms and Rules. For more information, see Export and import your indices.

Ranking#

Results are ranked by attributes and custom ranking.

For better performance, there is no ranking for:

distinct
typo-tolerance
number of matched words
proximity
geo distance

Reduce response size#

If you don’t need all attributes, you can reduce the size of the browse response. Use the attributesToRetrieve parameter to declare which attributes you want to retrieve.

Pagination#

The API clients return all results without pagination, often via iterators or similar constructs. If you need paginated results from the API, use the /browse HTTP API endpoint.

Examples # A

Get all records from an index#

Copy

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

// Use an API key with `browse` ACL
$client = SearchClient::create(
  'AJ0P3S7DWQ', 'YourAPIKey'
);
$index = $client->initIndex('indexName');

// Get all records
$records = $index->browseObjects();

foreach ($records as $hit) {
  var_dump($hit);
}

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

# Use an API key with `browse` ACL
client = Algolia::Search::Client.create(
  'AJ0P3S7DWQ', 'YourAPIKey'
)
index = client.init_index('indexName')

# Get all records as an iterator
index.browse_objects.each { |record| puts record }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const algoliasearch = require('algoliasearch');

// Use an API key with `browse` ACL
const client = algoliasearch('AJ0P3S7DWQ', 'YourAPIKey');
const index = client.initIndex('indexName');

let hits = [];

// Get all records as an iterator
index.browseObjects({
  batch: batch => {
    hits = hits.concat(batch);
  }
}).then(() => console.log(hits));

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

# Use an API key with `browse` ACL
client = SearchClient.create("AJ0P3S7DWQ", "YourAPIKey")
index = client.init_index("indexName")

# Get all records as iterator
for record in index.browse_objects():
    print(record)

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

// Use an API key with `browse` ACL
let client = SearchClient(
  appID: "AJ0P3S7DWQ",
  apiKey: "YourAPIKey"
)
let index = client.index(withName: "indexName")

// Get all records as iterator
index.browse(query: Query("")) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
// Use an API key with `browse` ACL
val client = ClientSearch(
  ApplicationID("AJ0P3S7DWQ"),
  APIKey("YourAPIKey")
)
val index = client.initIndex(IndexName("indexName"))

// Get all records as an iterator
index.browseObjects().forEach {
  responseSearch -> println(responseSearch)
}

1
2
3
4
5
6
7
8
9
10
11
// Use an API key with `browse` ACL
var client = new SearchClient("AJ0P3S7DWQ", "YourAPIKey");
var index = client.InitIndex("indexName");

// Get all records as a typed iterator
IndexIterator<Record> indexIterator = index.Browse<Record>(new BrowseIndexQuery {});

for (var record in indexIterator)
{
  Console.WriteLine(record);
}

1
2
3
4
5
6
7
8
// Use an API key with `browse` ACL
SearchClient client = DefaultSearchClient.create("AJ0P3S7DWQ", "YourAPIKey");
SearchIndex index = client.initIndex("indexName");

// Get all records as an iterator
for (Object record: index.browseObjects(new BrowseIndexQuery())) {
    System.out.println(record);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// Use an API key with `browse` ACL
client := search.NewClient("AJ0P3S7DWQ", "YourAPIKey")
index := client.InitIndex("indexName")

// Get all records as an iterator
it, err := index.BrowseObjects()

// Define the structure of your record
var record struct {
  ObjectID string `json:"objectID"`
  // add more attributes
}

for {
  _, err := it.Next(&record)
  if (err != nil) {
    if (err == io.EOF) {
      break
    } else {
      panic(err)
    }
  }
  fmt.Println(record.ObjectID)
}

1
2
3
4
5
6
7
8
9
10
11
12
// Use an API key with `browse` ACL
val client = new AlgoliaClient(
  applicationId = "AJ0P3S7DWQ",
  apiKey = "YourAPIKey"
)
val syncHelper = AlgoliaSyncHelper(client)
val q = Query()

// Get all records as an iterator
syncHelper
  .browse("myIndex", q)
  .map(println)

Get all records with only a few attributes#

The objectID attribute is always retrieved.

Copy

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
require_once __DIR__."/vendor/autoload.php";
use Algolia\AlgoliaSearch\SearchClient;

// Use an API key with `browse` ACL
$client = SearchClient::create(
  'AJ0P3S7DWQ', 'YourAPIKey'
);
$index = $client->initIndex('indexName');

// Get all records, retrieve only `title` and `content` attributes
$records = $index->browseObjects(
  ['query' => '', 'attributesToRetrieve' => [ 'title', 'content' ]]
);

foreach ($records as $hit) {
  var_dump($hit);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
require 'algolia'

# Use an API key with `browse` ACL
client = Algolia::Search::Client.create(
  'AJ0P3S7DWQ', 'YourAPIKey'
)
index = client.init_index('indexName')

records = index.browse_objects(
  { 'attributesToRetrieve': [ 'title', 'content' ] }
)

records.each { |hit| puts hit }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
const algoliasearch = require('algoliasearch');

// Use an API key with `browse` ACL
const client = algoliasearch('AJ0P3S7DWQ', 'YourAPIKey');
const index = client.initIndex('indexName');

let hits = [];

// Get all records, retrieve only `title` and `content` attributes
index.browseObjects({
  query: '',
  attributesToRetrieve: [
      "title",
      "content"
    ],
  batch: batch => {
    hits = hits.concat(batch);
  }
}).then(() => console.log(hits));

1
2
3
4
5
6
7
8
9
10
11
12
13
from algoliasearch.search_client import SearchClient

# Use an API key with `browse` ACL
client = SearchClient.create("AJ0P3S7DWQ", "YourAPIKey")
index = client.init_index("indexName")

# Get all records, retrieve only `title` and `content` attributes
records = index.browse_objects(
    {"attributesToRetrieve": ["title", "content"]}
)

for hit in records:
    print(hit)

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

// Use an API key with `browse` ACL
let client = SearchClient(
  appID: "AJ0P3S7DWQ",
  apiKey: "YourAPIKey"
)
let index = client.index(withName: "indexName")

// Get all records, retrieve only `title` and `content` attributes
var query = Query("") 
query.set(\.attributesToRetrieve, to: [
      "title",
      "content"
    ])
index.browse(query: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// Use an API key with `browse` ACL
val client = ClientSearch(
  ApplicationID("AJ0P3S7DWQ"),
  APIKey("YourAPIKey")
)
val index = client.initIndex(IndexName("indexName"))

// Get all records, retrieve only `title` and `content` attributes
val query = query("") {
  attributesToRetrieve {
    +"title"
    +"content"
  }
}
index.browseObjects(query).forEach { 
  responseSearch -> println(responseSearch.hits)
}

1
2
3
4
5
6
7
8
9
10
11
// Use an API key with `browse` ACL
var client = new SearchClient("AJ0P3S7DWQ", "YourAPIKey");
var index = client.InitIndex("indexName");

// Get all records, retrieve only `title` and `content` attributes
IndexIterator<T> indexIterator = index.Browse<T>(new BrowseIndexQuery { AttributesToRetrieve = new List<string> { "title", "content" } });

foreach (var record in indexIterator)
{
  Console.WriteLine(record)
}

1
2
3
4
5
6
7
8
9
10
11
12
// Use an API key with `browse` ACL
SearchClient client = DefaultSearchClient.create("AJ0P3S7DWQ", "YourAPIKey");
SearchIndex index = client.initIndex("indexName");

// Get all records, retrieve only `title` and `content` attributes
BrowseIndexQuery query = new BrowseIndexQuery().setAttributesToRetrieve(
  Arrays.asList("title", "content")
);

for (Object record: index.browseObjects(query)) {
  System.out.println(record);
}

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
// Use an API key with `browse` ACL
client := search.NewClient("AJ0P3S7DWQ", "YourAPIKey")
index := client.InitIndex("indexName")

// Get all records, retrieve only `title` and `content` attributes
it, err := index.BrowseObjects(
    opt.Query(""),
    opt.AttributesToRetrieve(
      "title",
      "content",
    ),
)

// Define the structure of your record
var record struct {
  ObjectID string `json:"objectID"`
  // add more attributes
}

for {
  _, err := it.Next(&record)
  if (err != nil) {
    if (err == io.EOF) {
      break
    } else {
      panic(err)
    }
  }
  fmt.Println(record.ObjectID)
}

1
2
3
4
5
6
7
8
9
10
11
12
// Use an API key with `browse` ACL
val client = new AlgoliaClient(
  applicationId = "YourAppplicationID",
  apiKey = "YourAPIKey"
)
val syncHelper = AlgoliaSyncHelper(client)
val q = Query(
  attributesToRetrieve = Some(Seq("title", "content"))
)
syncHelper
  .browse("indexName", q)
  .map(println)

Parameters # A

Parameter	Description
`query` #	type: string Required Search query. Use an empty query to fetch all objects.
`browseParameters` #	type: key/value mapping default: No browse parameters Optional Compatible search parameters. For example: Retrieve only certain attributes: `attributesToRetrieve` Filtering: `filters` `facetFilters` `numericFilters` `tagFilters` When using `browse`, the engine overrides these API parameters: `typoTolerance` can only be `true` or `false`. If you set `typoTolerance` to `min` or `strict`, the engine sets it to `true` (records matching up to 2 typos are retrieved) `distinct`: `false` `enableRules`: `false` `ignorePlurals`: `false` `advancedSyntax`: `false` `facets`: `[]` `getRankingInfo`: `false` `attributesToHighlight`: `[]` `attributesToSnippet`: `[]` `optionalFilters`: `[]` When using `browse`, the pagination parameters `hitsPerPage` and `page` are ignored. Personalization isn’t applied to browse requests. The `enablePersonalization` parameter is ignored.
`requestOptions` #	type: key/value mapping default: No request options Optional A mapping of `requestOptions` to send along with the query.

Response # A

This section shows the JSON response returned by the API. Each API client encapsulates this response inside objects specific to the programming language, so that the actual response might be different. You can view the response by using the getLogs method. Don’t rely on the order of attributes in the response, as JSON doesn’t guarantee the ordering of keys in objects.

JSON format#

Copy

          {
  "hits": [
    {
      "firstname": "Jimmie",
      "lastname": "Barninger",
      "objectID": "433"
    }
  ],
  "processingTimeMS": 7,
  "query": "",
  "params": "filters=level%3D20",
  "cursor": "ARJmaWx0ZXJzPWxldmVsJTNEMjABARoGODA4OTIzvwgAgICAgICAgICAAQ=="
}

        

Field	Description
`hits` #	list Retrieved records.
`cursor` #	string A cursor to retrieve the next chunk of objects. If absent, the end of the index has been reached.
`params` #	string URL-encoded search parameters used to filter the results.
`query` #	string Query text used to filter the results.
`processingTimeMS` #	integer Time that the server took to process the request, in milliseconds. This does not include network time.
`nbHits` #	integer Number of objects in the index. Present only when the query is empty and the browse is not filtered.
`page` #	integer Index of the current page (zero-based). Present only when the query is empty and the browse is not filtered.
`hitsPerPage` #	integer The maximum number of hits returned per page. Present only when the query is empty and the browse is not filtered.
`nbPages` #	integer The number of returned pages. Calculation is based on total number of hits (`nbHits`) divided by the number of hits per page (`hitsPerPage`), rounded to the nearest highest integer. Present only when the query is empty and the browse is not filtered.

Did you find this page helpful?

Browse index

About this method # Found an issue? Edit this page A Edit this page