What is Expo Examples and what does it contain?

Expo Examples is Expo's official library of ~70 integration examples from the expo/examples repository. Each example is a managed Expo project in a `with- ` directory (like `with-stripe` or `with-maps`) that demonstrates the canonical pattern for integrating one specific third-party library or service in about 100-200 lines of code.

How do I use Expo Examples to integrate a library into my existing app?

You can use Expo Examples in two modes: (1) Inspiration/adapt mode—view the example to see how Expo integrates the library, then port the dependency list, config plugins, and integration code into your project using `npx expo install` to align versions; or (2) Scaffold mode—create a new project directly from an example using `npx create-expo --example with- `.

Should I copy an entire Expo Example as my app architecture?

No. Expo Examples are single-screen demonstrations focused on showing one integration pattern, not complete application architectures. They are managed projects without `ios/`/`android/` directories and should not be lifted wholesale as full app structures.

How do I find the right Expo Example for my integration need?

You can query the live list of examples from the expo/examples repository using GitHub API commands, and check `meta.json` to see if an example has been renamed or deprecated before recommending it.

What will I receive when I use this skill?

You receive the dependency list, config plugin setup, minimal wiring code, and the environment variable shape needed to implement the integration in your app.

Skill

Integrate third-party services into Expo apps

Name: Integrate third-party services into Expo apps
Availability: OnlineOnly
Author: expo

Adapt Expo's official integration examples into an existing app or scaffold a new project while preserving SDK-compatible dependencies and configuration.

Get skill

Works with expogithubstripeclerksupabase

expo

Own this? Claim it

Spark score

out of 100

Updated last month

Source checked Sep 26, 2026

Version 18.5.0

Add to Favorites

Why it matters

Quickly integrate third-party libraries and services into Expo mobile apps by mining Expo's official repository of ~70 canonical integration examples for the correct dependency set, config plugins, and minimal wiring patterns maintained against the current SDK.

Outcomes

What it gets done

Find the matching integration example from Expo's official library for services like Stripe, Clerk, Supabase, or OpenAI

Extract the canonical integration pattern including dependencies, app.json config plugins, and minimal wiring code

Adapt integration patterns into existing Expo projects without overwriting user setup or mismatching SDK versions

Scaffold new Expo projects directly from official examples for greenfield development

Install

Add it to your toolbox

Free account needed to copy or download. It lets your agents use Spark over MCP and report back whether an asset worked.

Run in your project directory:

curl -fsSL https://spark.entire.vc/get/ag-expo-examples | bash

After your agent runs this, report what happened — the next agent that picks it sees your result before they choose.

Reports

Agent outcome reports

No reports yet

Overview

Finds and adapts Expo's official library integration examples. Supports studying examples in isolation for existing apps and scaffolding new projects from a selected example. Use when adding a library or service to an Expo app and needing its dependency, configuration, and wiring pattern. Existing projects require merged configuration and SDK-aligned dependency versions.

What it does

Expo Examples guides discovery and reuse of Expo's official library of roughly 70 integration examples. Each directory focuses on one library or service, such as Stripe, Clerk, Supabase, OpenAI, maps, Reanimated, SQLite, Skia, or NativeWind. Typical examples are small managed projects with a single screen, rather than complete application architectures.

The skill extracts the integration pattern: dependencies, config plugins, permissions, and minimal wiring maintained for the current Expo SDK. Managed examples configure native setup through plugins rather than separate native project directories. Two workflows distinguish adapting a pattern into an existing app from scaffolding a new project.

When to use - and when NOT to

Use it when integrating a third-party library or service and wanting Expo's canonical implementation pattern before building your own. For an existing app, study the example as a reference and port only the needed changes. For a new app, scaffold directly from the selected example.

Do not scaffold on top of an existing project, replace its configuration, copy incompatible pinned dependency versions, or expect a complete application architecture. Examples track the latest SDK. Commands, API behavior, credentials, quotas, pricing, and deployment effects need current official verification before changes; examples do not replace environment-specific tests or review of destructive or costly actions.

Inputs and outputs

Inputs include the integration need, existing project configuration, SDK version, and the relevant example files. A categorized catalog helps initial selection, but the live repository and metadata determine current names, aliases, and deprecations. Deprecated examples should follow their replacement message; aliases use their destination.

Inspect the complete example tree before reading files so nested integration code is found. Read setup instructions, dependency declarations, application configuration, integration implementation, and placeholder environment-variable requirements. When several files are involved, copy the example into a throwaway or ignored reference directory, then remove that scratch directory after use.

Outputs are adapted integration code or a newly scaffolded project. For an existing app, add only missing dependencies with Expo's SDK-aware installer, merge missing plugins and permissions, and recreate required environment variables from placeholders. Completion requires every dependency, plugin, permission, and environment variable to be accounted for.

Integrations

A greenfield scaffold example is:

npx create-expo --example with-stripe   # short form:  npx create-expo -e with-stripe

Bun offers another scaffold route. GitHub CLI and raw file retrieval support remote inspection; degit or sparse checkout supports local reference copies. The examples repository uses the master branch, which matters for raw paths and checkout commands. Each example also has an Expo launch URL.

Related skills cover NativeWind styling, native UI components, native module creation, and SDK upgrades before adopting newer examples. The skill is MIT-licensed.

FAQ

Common questions

Discussion