---
title: "AssetQuery"
description: "AssetQuery"
url: "https://www.contentstack.com/docs/developers/sdks/content-delivery-sdk/swift/reference/assetquery"
product: "Contentstack"
doc_type: "guide"
audience:
  - developers
  - admins
version: "current"
last_updated: "2026-09-04"
---

# AssetQuery

## AssetQuery

Use the AssetQuery class to fetch all or find assets. You obtain it from an initialized Stack via stack.asset().query().

**Class Overview**

Name

Type

Description

cachePolicy

CachePolicy

Defines the caching strategy for the AssetQuery request. While the Stack sets a default, you can manually override it using methods like .networkOnly to ensure the most recent data is retrieved.

stack

Stack

Identifies the parent Stack instance that owns and executes the query. This is automatically assigned by the system when you call stack.asset().query(), ensuring the request is correctly scoped to your environment.

parameters

\[String: Any\]

Contains URI-based metadata sent with the request. These are automatically populated by the system through method calls such as locale(), include(), skip(), and limit() to refine your API results.

queryParameter

\[String: Any\]

Defines the filtering logic (e.g., where) for the request. The system populates these values based on your method calls, allowing you to narrow down asset results to meet specific criteria.

headers

\[String: String\]

Manages custom HTTP headers for the request. You can manually add values via addValue(\_:forHTTPHeaderField:) to meet unique security or transport requirements.

## locale(_:)

The locale(\_:) method sets the locale used when fetching assets, so the response is in the specified language/locale.

```
The same AssetQuery instance, for chaining
let stack = Contentstack.stack(apiKey: apiKey,
                 deliveryToken: deliveryToken,
                 environment: environment)

     // To retrieve assets with a specific locale
     stack.asset().query().locale("en-us")
    .find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
        switch result {
        case .success(let contentstackResponse): // Models retrieved from API
        case .failure(let error): // Error Message
        }
     }Note: If locale(_:) is not called, the SDK does not provide a default value. The request is sent without a locale parameter, and the Contentstack Delivery API applies the Stack's default locale to the results.
```

Defines the locale code (e.g., "en-us") used to fetch assets in a specific language. It is set to ensure the API returns localized content.

## where(queryableCodingKey:_:)

Use this method to apply a filter on assets using a queryable field and a query operation (e.g., equals, includes).

```
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query()
.where(queryableCodingKey: .title, .equals("Asset Title"))
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
    switch result {
    case .success(let contentstackResponse):
    case .failure(let error):
    }
}
```

The member of your QueryableCodingKey that you are performing your select operation against.

The query operation used in the query.

## include(params:)

The include(params:) method adds optional response options (count, relative URLs, dimensions, fallback, metadata) to the asset query.

```
AssetQuery.Include options:
Option
Description
.count
Include the total count of assets in the response.
.relativeURL
Include relative URLs for assets.
.dimension
Include image dimensions (height/width). Supported types: JPG, GIF, PNG, WebP, BMP, TIFF, SVG, PSD.
.fallback
Return fallback locale content when the requested locale is not available.
.metadata
Include metadata in the response.
.all
Equivalent to [.count, .relativeURL, .dimension, .fallback, .metadata].
Examples
Include all options (.all):
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.all])
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
    switch result {
    case .success(let contentstackResponse):
    case .failure(let error):        //Error Message
    }
}Include count only (.count):
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.count]) 
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in 
  switch result { 
  case .success(let contentstackResponse): 
  case .failure(let error): 
  }
}Include relative URLs (.relativeURL):
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.relativeURL])
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in
    switch result {
    case .success(let contentstackResponse):
    case .failure(let error):
    }
}Include image dimensions (.dimension):
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.dimension]) 
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in 
  switch result { 
  case .success(let contentstackResponse): 
  case .failure(let error): 
  }
}Include fallback locale (.fallback):
let stack = Contentstack.stack(apiKey: "<API_KEY>", deliveryToken: "<DELIVERY_TOKEN>", environment: "<ENVIRNOMENT>")
stack.asset().query().include(params: [.fallback]) 
.find { (result: Result<ContentstackResponse<AssetModel>, Error>, response: ResponseType) in 
  switch result { 
  case .success(let contentstackResponse): 
  case .failure(let error): 
  }
}
```

Defines optional data you manually set in .include() to return assets with metadata or relative URLs.

## AssetQuery | Swift Delivery SDK | Contentstack

AssetQuery in the Swift Delivery SDK lets you build and execute queries to retrieve and filter assets stored in your Contentstack stack.