Create and use config plugins

Learn how to create and use a config plugins in your Expo project.

This guide covers sections how to create a config plugin, how to pass parameters to a config plugin, and how to chain multiple config plugins together. It also covers how to use a config plugin from an Expo library.

Using the diagram below, in this guide, you will learn the first two parts of the config plugin hierarchy:

Note: The following sections use dynamic app config (app.config.js/app.config.ts instead of app.json), which is not required to use a simple config plugin. However, it is required to use dynamic app config when you want to create/use a function-based config plugin that accepts parameters.

Creating a config plugin

In the following section, let's create a local config plugin that adds an arbitrary property HelloWorldMessage to the AndroidManifest.xml for Android and Info.plist for iOS.

This example will create and modify the following files. To follow along, create a plugins directory in the root of your project, and inside it, create withAndroidPlugin.ts, withIosPlugins.ts, and withPlugin.ts files.

import { ConfigPlugin, withAndroidManifest } from 'expo/config-plugins';

const withAndroidPlugin: ConfigPlugin = config => {
  // Define a custom message
  const message = 'Hello world, from Expo plugin!';

  return withAndroidManifest(config, config => {
    const mainApplication = config?.modResults?.manifest?.application?.[0];

    if (mainApplication) {
      // Ensure meta-data array exists
      if (!mainApplication['meta-data']) {
        mainApplication['meta-data'] = [];
      }

      // Add the custom message as a meta-data entry
      mainApplication['meta-data'].push({
        $: {
          'android:name': 'HelloWorldMessage',
          'android:value': message,
        },
      });
    }

    return config;
  });
};

export default withAndroidPlugin;

import { ConfigPlugin, withInfoPlist } from 'expo/config-plugins';

const withIosPlugin: ConfigPlugin = config => {
  // Define the custom message
  const message = 'Hello world, from Expo plugin!';

  return withInfoPlist(config, config => {
    // Add the custom message to the Info.plist file
    config.modResults.HelloWorldMessage = message;
    return config;
  });
};

export default withIosPlugin;

import { ConfigPlugin } from 'expo/config-plugins';
import withAndroidPlugin from './withAndroidPlugin';
import withIosPlugin from './withIosPlugin';

const withPlugin: ConfigPlugin = config => {
  // Apply Android modifications first
  config = withAndroidPlugin(config);
  // Then apply iOS modifications and return
  return withIosPlugin(config);
};

export default withPlugin;

import 'ts-node/register';

module.exports = () => {
  %%placeholder-start%%... rest of your app config %%placeholder-end%%
};

import "ts-node/register";
import { ExpoConfig } from "expo/config";

module.exports = ({ config }: { config: ExpoConfig }) => {
  %%placeholder-start%%... rest of your app config %%placeholder-end%%
  plugins: [
      ["./plugins/withPlugin.ts"],
    ],
};

<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<!-- ... rest of the configuration-->
	<application ...>
		<meta-data android:name="HelloWorldMessage" android:value="Hello world, from Expo plugin!"/>
		<!-- ... -->
	</application>
</manifest>

<plist version="1.0">
  <dict>
  <!-- ... -->
    <key>HelloWorldMessage</key>
    <string>Hello world, from Expo plugin!</string>
	<!-- ... -->
	</dict>
</plist>

Passing a parameter to a config plugin

Your config plugin can accept parameters passed from your app config. To do so, you will need to read the parameter in your config plugin function, and then pass an object containing the parameter along with the config plugin function in your app config.

%%placeholder-start%%...%%placeholder-end%%
type AndroidProps = {
  message?: string;
};

const withAndroidPlugin: ConfigPlugin<AndroidProps> = (
  config,
  options = {}
) => {
  const message = options.message || 'Hello world, from Expo plugin!';
  return withAndroidManifest(config, config => {
   %%placeholder-start%%... rest of the example remains unchanged %%placeholder-end%%
  });
};

export default withAndroidPlugin;

%%placeholder-start%%...%%placeholder-end%%
type IosProps = {
  message?: string;
};

const withIosPlugin: ConfigPlugin<IosProps> = (config, options = {}) => {
   const message = options.message || 'Hello world, from Expo plugin!';
  %%placeholder-start%%... rest of the example remains unchanged%%placeholder-end%%
};

export default withIosPlugin;

%%placeholder-start%%...%%placeholder-end%%
const withPlugin: ConfigPlugin<{ message?: string }> = (config, options = {}) => {
  config = withAndroidPlugin(config, options);
  return withIosPlugin(config, options);
};

{
  %%placeholder-start%%...%%placeholder-end%%
  plugins: [
    [
      "./plugins/withPlugin.ts",
      { message: "Custom message from app.config.ts" },
    ],
  ],
}

Chaining config plugins

Config plugins can be chained together to apply multiple modifications. Each plugin in the chain runs in the order it appears, with the output of one plugin becoming the input for the next. This sequential execution ensures that dependencies between plugins are respected and allows you to control the precise order of modifications to your native code.

To chain config plugins, you can pass an array of plugins to the plugins array property in your app config. This is also supported in JSON app config file format (app.json).

module.exports = ({ config }: { config: ExpoConfig }) => {
  name: 'my app',
  plugins: [
    [withFoo, 'input 1'],
    [withBar, 'input 2'],
    [withDelta, 'input 3'],
  ],
};

The plugins array uses withPlugins method under the hood to chain the plugins. If your plugins array is getting long or has complex configuration, you can use the withPlugins method directly to make your configuration easier to read. withPlugins will chain the plugins together and execute them in order.

import { withPlugins } from 'expo/config-plugins';

// Create a base config object
const baseConfig = {
  name: 'my app',
  %%placeholder-start%%... rest of the config %%placeholder-end%%
};

// ❌ Hard to read
withDelta(withFoo(withBar(config, 'input 1'), 'input 2'), 'input 3');

// ✅ Easy to read
withPlugins(config, [
  [withFoo, 'input 1'],
  [withBar, 'input 2'],
  // When no input is required, you can just pass the method
  withDelta,
]);

// Export the base config with plugins applied
module.exports = ({ config }: { config: ExpoConfig }) => {
  return withPlugins(baseConfig, plugins);
};

Using a config plugin

Expo config plugins are usually included in Node.js modules. You can install them just like other libraries in your project.

For example, expo-camera has a plugin that adds camera permissions to the AndroidManifest.xml and Info.plist. To install it in your project, run the following command:

In your app config, you can add expo-camera to the list of plugins:

{
  "expo": {
    "plugins": ["expo-camera"]
  }
}

Some config plugins offer flexibility by allowing you to pass options to customize their configuration. To do this, you can pass an array with the Expo library name as the first argument, and an object containing the options as the second argument. For example, the expo-camera plugin allows you to customize the camera permission message:

{
  "expo": {
    "plugins": [
      [
        "expo-camera",
        {
          "cameraPermission": "Allow $(PRODUCT_NAME) to access your camera."
        }
      ]
    ]
  }
}

Tip: For every Expo library that has a config plugin, you'll find more information about that in the library's API reference. For example, the expo-camera library has a config plugin section.

On running the npx expo prebuild, the mods are compiled, and the native files change.

The changes don't take effect until you rebuild the native project, for example, with Xcode. If you're using config plugins in a project without native directories (CNG projects), they will be applied during the prebuild step in EAS Build or when running npx expo prebuild|android|ios locally.