Streaming Assets

StreamingAssets is a special directory used for adding files that do not need to be processed by the build system.

The normal way to put content into a Player is for Unity to serialize scenesA Scene contains the environments and menus of your game. Think of each unique Scene file as a unique level. In each Scene, you place your environments, obstacles, and decorations, essentially designing and building your game in pieces. More info
See in Glossary and assets into binary files inside the generated Player when it builds the Project. However, you may also want to add additional files that are already in the correct format for the target platform and that your game code will load directly.

Example usages include:

Configuration files in json, xml, sqlite or other formats.
Video files, for example movie files on iOS devices.
Files required by plugins.
AssetBundles (described below).

The StreamingAssets folder must be created at the Assets root directory, e.g. Assets/StreamingAssets. This directory name is case sensitive, so it must be named exactly StreamingAssets rather than streamingassets or Streamingassets.

Unity copies any files placed in that directory verbatim into the Player output. Then, when deployed to a target deviceits contents will be placed in a location appropriate for the platform.

You can also add content from additional directories (outside of Assets/StreamingAssets) during the build process. This is done by calling the AddAdditionalPathToStreamingAssets method from a callback that implements BuildPlayerProcessor.PrepareForBuild. This is a good way to avoid the overhead of Unity importing each file, for example if your content is large and generated.

To retrieve the folder, use the Application.streamingAssetsPath property. It’s always best to use Application.streamingAssetsPath to get the location of the StreamingAssets folder, because it always points to the correct location on the platform where the application is running.

The location returned by Application.streamingAssetsPath varies per platform:

Most platforms (Unity Editor, Windows, Linux players) use Application.dataPath + "/StreamingAssets".
macOS player uses Application.dataPath + "/Resources/Data/StreamingAssets".
iOS uses Application.dataPath + "/Raw".
Android uses a directory that is inside a compressed APKThe Android Package format output by Unity. An APK is automatically deployed to your device when you select File > Build & Run. More info
See in Glossary/JAR file, for example "jar:file://" + Application.dataPath + "!/assets".
On Web, Application.streamingAssetsPath returns a HTTP URL that points to the StreamingAssets/ path on the web server. For example when running a local development server, the path might look like http://localhost:8000/unity_webgl_build/StreamingAssets/.
In play mode in the editor Application.streamingAssetsPaths will point to the Assets/StreamingAssets directory.

Accessing streaming assets

On most platforms the streamingAssets path is a directory that can be accessed using regular file system APIs.

However on Android and the Web platform, it’s not possible to access the streaming asset files directly via file system APIs and because these platforms return a URL. Use the UnityWebRequest class to access the content instead.

using UnityEngine;
using UnityEngine.Networking;
using System.Collections;

// Example of loading a file from the StreamingAssets folder
// This assumes that a file "config.json" has been placed in the Assets/StreamingAssets folder
public class LoadStreamingAssets : MonoBehaviour
{
    void Start()
    {
        StartCoroutine(LoadFile());
    }

    IEnumerator LoadFile()
    {
        string jsonData = "";
        string filePath = System.IO.Path.Combine(Application.streamingAssetsPath, "config.json");

        if (filePath.StartsWith("jar") || filePath.StartsWith("http"))
        {
            // Special case to access StreamingAsset content on Android and Web
            UnityWebRequest request = UnityWebRequest.Get(filePath);
            yield return request.SendWebRequest();

            if (request.result == UnityWebRequest.Result.Success)
            {
                jsonData = request.downloadHandler.text;
            }
        }
        else
        {
            // This is a regular file path on most platforms and in playmode of the editor
            jsonData = System.IO.File.ReadAllText(filePath);
        }

        Debug.Log("Loaded JSON Data: " + jsonData);
    }
}

Notes:

In the runtime the streamingAssets location is read-only. Don’t modify or write new files to that directory. Instead you can use Application.persistentDataPath or another writeable location.
Do not put Unity files (.unity, .prefab, .asset, etc) into the StreamingAssets folder. Those files need to be processed by a Player or AssetBundle build in order to be loadable in the runtime.
.dll and script files located in the StreamingAssets folder aren’t included during script compilation.

AssetBundles and the StreamingAssets folder

The StreamingAssets folder is useful if you intend to distribute AssetBundles directly in the Player installation, rather than downloading them on-demand.

To do this:

Build the AssetBundles to an output path inside Assets/StreamingAssets. Note: the .manifest files that are generated alongside the AssetBundle files are not required in the runtime, so they can be removed. See also Output of the Build.
Build the Player. The AssetBundles will be included in the platform-specific output.
Write loading code that uses the Application.streamingAssetsPath to determine the path to the AssetBundles. Depending on the platform, you would either load them as a local file path, or with UnityWebRequestAssetBundle. Note: On Android it is not necessary to cache the AssetBundle, nor to perform CRC checks, because the file is already present on local storage.

The Addressables package uses this mechanism automatically for local content.

Alternatively, AssetBundles and Addressables can be hosted on the Internet and downloaded on-demand rather than using the StreamingAssets folder. This is preferred for situations where the content is large, or frequently updated, or where you want to avoid the overhead of releasing new Player builds when you want to change or add new content.

Did you find this page useful? Please give it a rating:

Report a problem on this page

Loading Resources at Runtime

Modifying Source Assets Through Scripting

Unity Manual

Streaming Assets

Accessing streaming assets

AssetBundles and the StreamingAssets folder