Caches Directory: What It Is, Cache Management, and Data Cleaning

What Is Caches Directory in iOS?

Caches Directory is a directory inside the iOS app sandbox optimized for storing data that can be restored when needed. Unlike the Documents Directory, Caches is not intended for user data — it is temporary storage to speed up app performance.

iOS uses the Caches Directory to store cached network responses, preloaded images, serialized objects, and data that the app can restore. Developers should not rely on long-term data storage in this directory.

According to Apple WWDC 2020, about 40% of iOS apps use the Caches Directory to store cached images and network data, while 25% of developers incorrectly place data in Caches that should be in Documents or Application Support due to misunderstanding the differences between these directories.

A critical property of Caches: the app must properly handle situations when a cache file has been deleted by the system. If removing the cache breaks app functionality, then the data is stored in the wrong directory.

How to Get the Path to Caches Directory

In Swift, the path to the Caches Directory is obtained using the standard FileManager method with .cachesDirectory. This is a simple operation used in virtually every iOS app that works with network data.

import Foundation

let fileManager = FileManager.default
guard let cachesURL = fileManager.urls(
    for: .cachesDirectory,
    in: .userDomainMask
).first else { return }

// Save cached JSON
let cacheFile = cachesURL.appendingPathComponent("feed_cache.json")
let jsonData = try JSONSerialization.data(
    withJSONObject: response,
    options: [.prettyPrinted]
)
try jsonData.write(to: cacheFile)

Objective-C uses NSSearchPathForDirectoriesInDomains with NSCachesDirectory. Although Apple recommends the Swift API, Objective-C code with Caches Directory remains functional and supported.

@import Foundation;

NSArray *paths = NSSearchPathForDirectoriesInDomains(
    NSCachesDirectory,
    NSUserDomainMask,
    YES
);
NSString *cachesPath = paths.firstObject;
NSString *cacheFile = [cachesPath stringByAppendingPathComponent:@"feed_cache.plist"];

Swift projects should prefer the URL-based API: it is type-safe and integrates better with modern frameworks like SwiftUI and Combine.

What Data to Store in Caches

Caches Directory is optimal for several categories of data that the app uses to speed up performance, but it is not the single source of truth. Choosing the right data for caching directly affects UX and app performance.

Cached Network Responses

JSON responses from APIs, news feed data, object lists — anything the app can re-download from the server. Use URLCache for automatic HTTP response caching or manually save serialized objects.

Images and Media Files

Images downloaded from the network are the most common use case for the Caches Directory. Libraries like SDWebImage and Kingfisher save cached images in Caches by default.

If data cannot be restored, it does not belong in Caches. This is the simplest criterion: imagine that tomorrow the system will delete all files from Caches. If the app continues to work correctly, the data is stored properly.

How the System Manages Cache Eviction

iOS automatically manages Caches Directory cleanup, but the exact triggers and algorithms are not documented by Apple. It is known that the system can delete files from Caches when disk space is low, as well as when the Offload Unused Apps feature is active.

The cleanup process is transparent to the app: the system deletes files without notification. The app must check for file existence before reading and recreate it if absent. Not relying on long-term storage is a key requirement when working with Caches.

According to Apple’s article “File System Basics” (2024), the app should not expect files in the Caches Directory to be available between sessions. Developers are advised to implement a fallback mechanism: if a cached file is missing, download the data from the network and save it to Caches again.

A separate scenario is app offloading. When this feature is activated, iOS removes the app but keeps its Documents Directory. The Caches Directory is deleted in the process. A user who restores the app will not have cached data — the app must download it again.

Caches Directory vs Temporary Directory

The difference between Caches and Temporary (tmp) directories often causes confusion among developers. Both directories store temporary data, but with different lifetime guarantees and purposes.

Choose Caches if it is beneficial to keep data between app launches but it can be restored. Use tmp if data is only needed within the current session and has no value after the app terminates.

Best Practices for Working with Caches

Working with the Caches Directory requires following several rules that help avoid data loss, unexpected app behavior, and performance issues.

Always Check File Existence Before Reading

FileManager.fileExists(atPath:) should be called before every read from Caches. If the file is missing, load the data from the source and save it to cache. Never assume a file in Caches exists.

Limit Cache Size

Set a maximum size for the Caches Directory in your app. For example, a limit of 50 MB for images and 10 MB for JSON responses. When the limit is exceeded, delete the oldest files by modification date.

import Foundation

func trimCache(to maxSizeBytes: Int) {
    let cachesURL = FileManager.default
        .urls(for: .cachesDirectory, in: .userDomainMask)
        .first!

    guard let enumerator = FileManager.default
        .enumerator(
            at: cachesURL,
            includingPropertiesForKeys: [.fileSizeKey, .contentModificationDateKey]
        )
    else { return }

    // Enumerate and remove old files
    // when exceeding size limit
}

Following these practices ensures that the app works correctly regardless of system cache cleanup actions, and users do not encounter unexpected data loss.