> ## Documentation Index
> Fetch the complete documentation index at: https://algolia.com/llms.txt
> Use this file to discover all available pages before exploring further.

# attributesToRetrieve

> List of attributes to include in each record returned by a search query

export const Setting = ({type, default: defaultValue, defaultNote, scope, min, max, formerly}) => {
  const renderedDefault = defaultValue === '' ? '""' : defaultValue;
  const renderedNote = defaultNote ? `(${defaultNote})` : '';
  return <ul>
      <li><strong>Type:</strong> <code>{type}</code></li>
      <li><strong>Default:</strong> <code>{renderedDefault}</code>{renderedNote}</li>
      {min && <li><strong>Min:</strong> <code>{min}</code></li>}
      {max && <li><strong>Max:</strong> <code>{max}</code></li>}
      <li><strong>Scope:</strong> <a href="/doc/api-reference/api-parameters"><code>{scope}</code></a></li>
      {formerly && <li>
          <strong>Deprecated name:</strong> <code>{formerly}</code>
        </li>}
    </ul>;
};

<Setting type="list<string>" default="[&#x22;*&#x22;]" scope="search,settings" formerly="attributes" />

This parameter controls which attributes are included with each record in the search response.

Retrieving only the necessary attributes can reduce record size,
improve search performance, and speed up network transfers.

Use this parameter when you don't need all attributes—for example,
to exclude internal metadata or large, unnecessary fields.

## Usage

* Attribute names are case-sensitive.
* `objectID` is always retrieved, even when not specified.
* Use `*` to include all attributes.
* Use `-attributeName` (combined with `*`) to exclude specific attributes.
  This can be useful if you want to hide sensitive data—for example,
  if you don't want to expose your [custom ranking](/doc/guides/managing-results/must-do/custom-ranking)
  attributes.
* Attributes listed in [`unretrievableAttributes`](/doc/api-reference/api-parameters/unretrievableAttributes)
  are never retrieved unless the request is authenticated with the Admin API key.
* Nested attributes are supported. For example, `author.name` returns:
  `{"author": {"name": "Agatha Christie"}}`.

<Info>
  There's no hard limit on the number of attributes you can include,
  but adding too many can slow down [`getSettings`](/doc/rest-api/search/get-settings) operations
  and degrade performance in the Algolia dashboard.
</Info>

## Examples

### Set default list of retrievable attributes

<AccordionGroup>
  <Accordion title="Current API clients" defaultOpen="true">
    <CodeGroup>
      ```cs C# theme={"system"}
      var response = await client.SetSettingsAsync(
        "INDEX_NAME",
        new IndexSettings
        {
          AttributesToRetrieve = new List<string> { "author", "title", "content" },
        }
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.setSettings(
        indexName: "INDEX_NAME",
        indexSettings: IndexSettings(
          attributesToRetrieve: [
            "author",
            "title",
            "content",
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SetSettings(client.NewApiSetSettingsRequest(
        "INDEX_NAME",
        search.NewEmptyIndexSettings().SetAttributesToRetrieve(
          []string{"author", "title", "content"})))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      UpdatedAtResponse response = client.setSettings(
        "INDEX_NAME",
        new IndexSettings().setAttributesToRetrieve(Arrays.asList("author", "title", "content"))
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.setSettings({
        indexName: 'theIndexName',
        indexSettings: { attributesToRetrieve: ['author', 'title', 'content'] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(attributesToRetrieve = listOf("author", "title", "content")),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->setSettings(
          'INDEX_NAME',
          ['attributesToRetrieve' => [
              'author',

              'title',

              'content',
          ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.set_settings(
          index_name="INDEX_NAME",
          index_settings={
              "attributesToRetrieve": [
                  "author",
                  "title",
                  "content",
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.set_settings(
        "INDEX_NAME",
        Algolia::Search::IndexSettings.new(attributes_to_retrieve: ["author", "title", "content"])
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(
            attributesToRetrieve = Some(Seq("author", "title", "content"))
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response = try await client.setSettings(
          indexName: "INDEX_NAME",
          indexSettings: IndexSettings(attributesToRetrieve: ["author", "title", "content"])
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      IndexSettings settings = new IndexSettings
      {
          AttributesToRetrieve = new List { "author", "title", "content" }
      };
      ```

      ```go Go theme={"system"}
      res, err := index.SetSettings(search.Settings{
       AttributesToRetrieve: opt.AttributesToRetrieve(
        "author",
        "title",
        "content",
       ),
      })
      ```

      ```java Java theme={"system"}
      index.setSettings(
        new IndexSettings().setAttributesToRetrieve(Arrays.asList(
          "author",
          "title",
          "content"
        ))
      );
      ```

      ```js JavaScript theme={"system"}
      index.setSettings({
        attributesToRetrieve: ["author", "title", "content"],
      });
      ```

      ```kotlin Kotlin theme={"system"}
      val settings = settings {
          attributesToRetrieve {
              +"author"
              +"title"
              +"content"
          }
      }

      index.setSettings(settings)
      ```

      ```php PHP theme={"system"}
      $index->setSettings([
        'attributesToRetrieve' => [
          'author',
          'title',
          'content'
        ]
      ]);
      ```

      ```python Python theme={"system"}
      index.set_settings({"attributesToRetrieve": ["author", "title", "content"]})
      ```

      ```ruby Ruby theme={"system"}
      index.set_settings(
        {
          attributesToRetrieve: [
            "author",
            "title",
            "content"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        setSettings of "myIndex" `with` IndexSettings(
          attributesToRetrieve = Some(Seq(
            "author",
            "title",
            "content"
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let settings = Settings()
        .set(\.attributesToRetrieve, to: [
          "author",
          "title",
          "content"
        ])

      index.setSettings(settings) { result in
        if case .success(let response) = result {
          print("Response: \(response)")
        }
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>

### Make all attributes retrievable by default

<AccordionGroup>
  <Accordion title="Current API clients" defaultOpen>
    <CodeGroup>
      ```cs C# theme={"system"}
      var response = await client.SetSettingsAsync(
        "INDEX_NAME",
        new IndexSettings { AttributesToRetrieve = new List<string> { "*" } }
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.setSettings(
        indexName: "INDEX_NAME",
        indexSettings: IndexSettings(
          attributesToRetrieve: [
            "*",
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SetSettings(client.NewApiSetSettingsRequest(
        "INDEX_NAME",
        search.NewEmptyIndexSettings().SetAttributesToRetrieve(
          []string{"*"})))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      UpdatedAtResponse response = client.setSettings("INDEX_NAME", new IndexSettings().setAttributesToRetrieve(Arrays.asList("*")));
      ```

      ```js JavaScript theme={"system"}
      const response = await client.setSettings({
        indexName: 'theIndexName',
        indexSettings: { attributesToRetrieve: ['*'] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(attributesToRetrieve = listOf("*")),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->setSettings(
          'INDEX_NAME',
          ['attributesToRetrieve' => [
              '*',
          ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.set_settings(
          index_name="INDEX_NAME",
          index_settings={
              "attributesToRetrieve": [
                  "*",
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.set_settings("INDEX_NAME", Algolia::Search::IndexSettings.new(attributes_to_retrieve: ["*"]))
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(
            attributesToRetrieve = Some(Seq("*"))
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response = try await client.setSettings(
          indexName: "INDEX_NAME",
          indexSettings: IndexSettings(attributesToRetrieve: ["*"])
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      IndexSettings settings = new IndexSettings
      {
          AttributesToRetrieve = new List { "*" }
      };
      ```

      ```go Go theme={"system"}
      res, err := index.SetSettings(search.Settings{
       AttributesToRetrieve: opt.AttributesToRetrieve(
        "*",
       ),
      })
      ```

      ```java Java theme={"system"}
      index.setSettings(
        new IndexSettings().setAttributesToRetrieve(Collections.singletonList(
          "*"
        ))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .setSettings({
          attributesToRetrieve: ["*"],
        })
        .then(() => {
          // done
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val settings = settings {
          attributesToRetrieve { +"*" }
      }

      index.setSettings(settings)
      ```

      ```php PHP theme={"system"}
      $index->setSettings([
        'attributesToRetrieve' => [
          "*"
        ]
      ]);
      ```

      ```python Python theme={"system"}
      index.set_settings({"attributesToRetrieve": ["*"]})
      ```

      ```ruby Ruby theme={"system"}
      index.set_settings(
        {
          attributesToRetrieve: [
            "*"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        setSettings of "myIndex" `with` IndexSettings(
          replaceSynonymsInHighlight = Some(false)
        )
      }
      ```

      ```swift Swift theme={"system"}
      let settings = Settings()
        .set(\.attributesToRetrieve, to: ["*"])

      index.setSettings(settings) { result in
        if case .success(let response) = result {
          print("Response: \(response)")
        }
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>

### Override default list of retrievable attributes for the current search

<AccordionGroup>
  <Accordion title="Current API clients" defaultOpen>
    <CodeGroup>
      ```cs C# theme={"system"}
      var response = await client.SearchSingleIndexAsync<Hit>(
        "INDEX_NAME",
        new SearchParams(
          new SearchParamsObject
          {
            Query = "query",
            AttributesToRetrieve = new List<string> { "title", "content" },
          }
        )
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.searchSingleIndex(
        indexName: "INDEX_NAME",
        searchParams: SearchParamsObject(
          query: "query",
          attributesToRetrieve: [
            "title",
            "content",
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SearchSingleIndex(client.NewApiSearchSingleIndexRequest(
        "INDEX_NAME").WithSearchParams(search.SearchParamsObjectAsSearchParams(
        search.NewEmptySearchParamsObject().SetQuery("query").SetAttributesToRetrieve(
          []string{"title", "content"}))))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      SearchResponse response = client.searchSingleIndex(
        "INDEX_NAME",
        new SearchParamsObject().setQuery("query").setAttributesToRetrieve(Arrays.asList("title", "content")),
        Hit.class
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.searchSingleIndex({
        indexName: 'indexName',
        searchParams: { query: 'query', attributesToRetrieve: ['title', 'content'] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams =
            SearchParamsObject(query = "query", attributesToRetrieve = listOf("title", "content")),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->searchSingleIndex(
          'INDEX_NAME',
          ['query' => 'query',
              'attributesToRetrieve' => [
                  'title',

                  'content',
              ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.search_single_index(
          index_name="INDEX_NAME",
          search_params={
              "query": "query",
              "attributesToRetrieve": [
                  "title",
                  "content",
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.search_single_index(
        "INDEX_NAME",
        Algolia::Search::SearchParamsObject.new(query: "query", attributes_to_retrieve: ["title", "content"])
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.searchSingleIndex(
          indexName = "INDEX_NAME",
          searchParams = Some(
            SearchParamsObject(
              query = Some("query"),
              attributesToRetrieve = Some(Seq("title", "content"))
            )
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response: SearchResponse<Hit> = try await client.searchSingleIndex(
          indexName: "INDEX_NAME",
          searchParams: SearchSearchParams.searchSearchParamsObject(SearchSearchParamsObject(
              query: "query",
              attributesToRetrieve: ["title", "content"]
          ))
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      index.Search(new Query("query")
      {
          AttributesToRetrieve = new List{ "title", "content" }
      });
      ```

      ```go Go theme={"system"}
      res, err := index.Search("query", search.Settings{
       AttributesToRetrieve: opt.AttributesToRetrieve(
        "title",
        "content",
       ),
      })
      ```

      ```java Java theme={"system"}
      index.search(
        new Query("query").setAttributesToRetrieve(Arrays.asList(
          "title",
          "content"
        ))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .search("query", {
          attributesToRetrieve: ["title", "content"],
        })
        .then(({ hits }) => {
          console.log(hits);
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val query = query("query") {
          attributesToRetrieve {
              +"title"
              +"content"
          }
      }

      index.search(query)
      ```

      ```php PHP theme={"system"}
      $results = $index->search('query', [
        'attributesToRetrieve' => [
          'title',
          'content'
        ]
      ]);
      ```

      ```python Python theme={"system"}
      results = index.search("query", {"attributesToRetrieve": ["title", "content"]})
      ```

      ```ruby Ruby theme={"system"}
      results = index.search(
        "query",
        {
          attributesToRetrieve: [
            "title",
            "content"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        search into "myIndex" query Query(
          query = Some("query"),
          attributesToRetrieve = Some(Seq(
            "title",
            "content"
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let query = Query("query")
        .set(\.attributesToRetrieve, to: [
          "title",
          "content"
        ])

      index.search(query: query) { result in
        if case .success(let response) = result {
          print("Response: \(response)")
        }
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>

### Specify some attributes not to retrieve

Retrieve all attributes of an item except for its SKU and internal description.

<AccordionGroup>
  <Accordion title="Current API clients" defaultOpen>
    <CodeGroup>
      ```cs C# theme={"system"}
      var response = await client.SetSettingsAsync(
        "INDEX_NAME",
        new IndexSettings
        {
          AttributesToRetrieve = new List<string> { "*", "-SKU", "-internal_desc" },
        }
      );
      ```

      ```dart Dart theme={"system"}
      final response = await client.setSettings(
        indexName: "INDEX_NAME",
        indexSettings: IndexSettings(
          attributesToRetrieve: [
            "*",
            "-SKU",
            "-internal_desc",
          ],
        ),
      );
      ```

      ```go Go theme={"system"}
      response, err := client.SetSettings(client.NewApiSetSettingsRequest(
        "INDEX_NAME",
        search.NewEmptyIndexSettings().SetAttributesToRetrieve(
          []string{"*", "-SKU", "-internal_desc"})))
      if err != nil {
        // handle the eventual error
        panic(err)
      }
      ```

      ```java Java theme={"system"}
      UpdatedAtResponse response = client.setSettings(
        "INDEX_NAME",
        new IndexSettings().setAttributesToRetrieve(Arrays.asList("*", "-SKU", "-internal_desc"))
      );
      ```

      ```js JavaScript theme={"system"}
      const response = await client.setSettings({
        indexName: 'theIndexName',
        indexSettings: { attributesToRetrieve: ['*', '-SKU', '-internal_desc'] },
      });
      ```

      ```kotlin Kotlin theme={"system"}
      var response =
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(attributesToRetrieve = listOf("*", "-SKU", "-internal_desc")),
        )
      ```

      ```php PHP theme={"system"}
      $response = $client->setSettings(
          'INDEX_NAME',
          ['attributesToRetrieve' => [
              '*',

              '-SKU',

              '-internal_desc',
          ],
          ],
      );
      ```

      ```python Python theme={"system"}
      response = client.set_settings(
          index_name="INDEX_NAME",
          index_settings={
              "attributesToRetrieve": [
                  "*",
                  "-SKU",
                  "-internal_desc",
              ],
          },
      )
      ```

      ```ruby Ruby theme={"system"}
      response = client.set_settings(
        "INDEX_NAME",
        Algolia::Search::IndexSettings.new(attributes_to_retrieve: ["*", "-SKU", "-internal_desc"])
      )
      ```

      ```scala Scala theme={"system"}
      val response = Await.result(
        client.setSettings(
          indexName = "INDEX_NAME",
          indexSettings = IndexSettings(
            attributesToRetrieve = Some(Seq("*", "-SKU", "-internal_desc"))
          )
        ),
        Duration(100, "sec")
      )
      ```

      ```swift Swift theme={"system"}
      let response = try await client.setSettings(
          indexName: "INDEX_NAME",
          indexSettings: IndexSettings(attributesToRetrieve: ["*", "-SKU", "-internal_desc"])
      )
      ```
    </CodeGroup>
  </Accordion>

  <Accordion title="Legacy API clients">
    <CodeGroup>
      ```cs C# theme={"system"}
      IndexSettings settings = new IndexSettings
      {
          AttributesToRetrieve = new List { "*", "-SKU", "-internal_desc" }
      };
      ```

      ```go Go theme={"system"}
      res, err := index.SetSettings(search.Settings{
       AttributesToRetrieve: opt.AttributesToRetrieve(
        "*",
        "-SKU",
        "-internal_desc",
       ),
      })
      ```

      ```java Java theme={"system"}
      index.setSettings(
        new IndexSettings().setAttributesToRetrieve(Arrays.asList(
          "*",
          "-SKU",
          "-internal_desc"
        ))
      );
      ```

      ```js JavaScript theme={"system"}
      index
        .setSettings({
          attributesToRetrieve: ["*", "-SKU", "-internal_desc"],
        })
        .then(() => {
          // done
        });
      ```

      ```kotlin Kotlin theme={"system"}
      val settings = settings {
          attributesToRetrieve {
              +"sku"
              +"internal_desc"
              excludeAttributes = true
          }
      }

      index.setSettings(settings)
      ```

      ```php PHP theme={"system"}
      $index->setSettings([
        'attributesToRetrieve' => [
          '*',
          '-SKU',
          '-internal_desc'
        ]
      ]);
      ```

      ```python Python theme={"system"}
      index.set_settings({"attributesToRetrieve": ["*", "-SKU", "-internal_desc"]})
      ```

      ```ruby Ruby theme={"system"}
      index.set_settings(
        {
          attributesToRetrieve: [
            "*",
            "-SKU",
            "-internal_desc"
          ]
        }
      )
      ```

      ```scala Scala theme={"system"}
      client.execute {
        setSettings of "myIndex" `with` IndexSettings(
          attributesToRetrieve = Some(Seq(
            "*",
            "-SKU",
            "-internal_desc"
          ))
        )
      }
      ```

      ```swift Swift theme={"system"}
      let settings = Settings()
        .set(\.attributesToRetrieve, to: [
          "*",
          "-SKU",
          "-internal_desc"
        ])

      index.setSettings(settings) { result in
        if case .success(let response) = result {
          print("Response: \(response)")
        }
      }
      ```
    </CodeGroup>
  </Accordion>
</AccordionGroup>