You have two choices for when to instantiate the Optimizely client: **synchronous** and **asynchronous**. The _behavioral_ difference between the two methods is whether your application pings the Optimizely servers for a new datafile during initialization. The _functional_ difference between the two methods is whether your app prioritizes accuracy or speed.
Important
You much decide to initialize your SDK _either_ synchronously or asynchronously. You cannot use both initialization methods.
## Synchronous initialization
The synchronous method prioritizes speed over accuracy. Instead of attempting to download a new datafile every time you initialize an Optimizely client, your app uses a local version of the datafile. This local datafile can be cached from a previous network request (see [Configure datafile polling](🔗)) or embedded within your app (see [Enable bundled datafiles](🔗)).
When you initialize a client synchronously, the Optimizely manager first searches for a [cached datafile](🔗). If one is available, the manager uses it to complete the client initialization. If the manager can't find a cached datafile, the manager searches for a [bundled datafile](🔗). If the manager finds a the bundled datafile, it uses the datafile to complete the client initialization. If the manager can't find a bundled datafile, the manager can't initialize the client.
## Asynchronous initialization
The asynchronous method prioritizes accuracy over speed. During initialization, your app requests the newest datafile from the CDN servers. Requesting the newest datafile ensures that your app always uses the most current project settings, but it also means your app cannot instantiate a client until it downloads a new datafile, discovers the datafile has not changed, or until the request times out. This process takes time.
Initializing a client asynchronously executes like the [synchronous initialization](🔗), except the manager will first attempt to download the newest datafile. This network activity is what causes an asynchronous initialization to take longer to complete.
If the network request returns an error (such as when network connectivity is unreliable) or if the manager discovers that the cached datafile is identical to the newest datafile, the manager then uses the synchronous approach. If manager discovers that the datafile has been updated and now differs from the cached datafile, the manager downloads the new datafile and uses it to initialize the client.
## Android
To initialize an `OptimizelyClient` object **synchronously**, call `OptimizelyManager#initialize()` and provide two arguments:
The Application instance (from `
android.app.Application`)An `
Integer` pointer to the application resource datafile
For more details on the specific requirements, view [`OptimizelyManager.java` from the publicly available Android SDK](🔗).
To initialize an `OptimizelyClient` object **asynchronously**, call `OptimizelyManager#initialize()` and three arguments:
The Application instance (from `
android.app.Application`)An `
Integer` pointer to the application resource datafileA listener object
For more details on the specific requirements and to see how to build each object, view [`OptimizelyManager.java` from the publicly available Android SDK](🔗).
## iOS
To initialize an `OPTLYClient` object **synchronously**, call `[manager initialize]` or `[manager initializeWithDatafile:datafile]`.
To initialize an `OPTLYClient` object **asynchronously**, call `[manager initializeWithCallback:callback]` and pass it a callback function.
Important
The datafile you pass must have the same project ID that you provided when initializing the Optimizely manager.