Official agent skill

Eas Hosting

by expo in expo/skills

Deploy Expo websites and Expo Router API routes to EAS Hosting - export the web bundle, run eas deploy for production and PR preview URLs, manage environment secrets and custom domains, and work…

OfficialMITAuto-check: notesMobile

Install Eas Hosting

skills CLI
$ npx skills add expo/skills --skill eas-hosting -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install expo/skills eas-hosting --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/expo/skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/plugins/expo/skills/eas-hosting .claude/skills/eas-hosting && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
eas-hosting
GitHub stars
2.7k
Used in
2 other repos
Token cost
~2.9k tokens
SKILL.md length
683 words
Files
2
Skills in repo
26
Repo updated
First seen
Licence
MIT

At a glance

Deploy Expo websites and Expo Router API routes to EAS Hosting - export the web bundle, run eas deploy for production and PR preview URLs, manage environment secrets and custom domains, and work…

  • Deploying an Expo web app
  • SKILL.md covers When to Use API Routes, When NOT to Use API Routes, File Structure and Basic API Route, plus 12 more sections
  • Calls npx, eas and curl; reaches api.openai.com and docs.expo.dev; needs OPENAI_API_KEY and TURSO_AUTH_TOKEN
  • Setting up EAS Hosting

What it does

Eas Hosting is an agent skill from expo/skills, published by the product's own GitHub organization. Deploy Expo websites and Expo Router API routes to EAS Hosting - export the web bundle, run eas deploy for production and PR preview URLs, manage environment secrets and custom domains, and work within the Cloudflare Workers runtime. Also covers authoring API routes (+api.ts handlers, HTTP methods, request handling, CORS). Use when deploying an Expo web app or API routes, setting up EAS Hosting, or configuring hosting environments and domains. Not for native builds or store releases - use the eas-app-stores skill…

Its SKILL.md is about 2.9k tokens, which your agent loads only when the skill is triggered. The skill folder holds 2 other files (for example `agents/openai.yaml`).

It sits in Mobile, covering Cross-platform mobile apps and App store release. It works with Expo and Cloudflare Workers. The repository describes itself as: A collection of AI agent skills for working with Expo projects and Expo Application Services. The licence is MIT.

When your agent uses it

  • Deploying an Expo web app
  • Setting up EAS Hosting
  • Configuring hosting environments and domains

Example prompts

  • “/eas-hosting”

Requirements

  • Node.js
  • A credential in OPENAI_API_KEY
  • A credential in TURSO_AUTH_TOKEN

What it can do on your machine

Read from SKILL.md and the folder at commit d4f4840. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npx
    • eas
    • curl
    • npm

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • api.openai.com
    • docs.expo.dev
    • api.weather.com

    Also links to:

    • expo.dev

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • OPENAI_API_KEY
    • TURSO_AUTH_TOKEN
    • WEATHER_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Eas Hosting loads about 2.9k tokens when it runs. Until then it costs about 135 tokens; SKILL.md has 683 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~135
When it runs · the whole SKILL.md, loaded when a task matches
~2.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check: notes

The automated check noted patterns worth knowing about, such as sudo or a known installer.

  • NoteMentions a .env fileSKILL.md:164
    - **Local**: Create `.env` file (never commit)

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from expo/skills at commit d4f4840, republished under its MIT licence (© expo). 683 words, ~2,861 tokens.

Download SKILL.mdSave it as .claude/skills/eas-hosting/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
eas-hosting
description
Deploy Expo websites and Expo Router API routes to EAS Hosting - export the web bundle, run eas deploy for production and PR preview URLs, manage environment secrets and custom domains, and work within the Cloudflare Workers runtime. Also covers authoring API routes (+api.ts handlers, HTTP methods, request handling, CORS). Use when deploying an Expo web app or API routes, setting up EAS Hosting, or configuring hosting environments and domains. Not for native builds or store releases - use the eas-app-stores skill for those.
version
1.0.0
license
MIT

EAS Hosting

EAS service - costs apply. EAS Hosting is a paid Expo Application Services product with free-tier limits; production deploys use your plan's request and bandwidth allowance. See https://expo.dev/pricing. Authoring API routes and exporting the web bundle are free and open source, and you can self-host the exported server output instead of EAS Hosting.

EAS Hosting deploys your Expo web app and API routes to Expo's managed edge (Cloudflare Workers). Export the web bundle with npx expo export -p web and ship it with eas deploy - the same command deploys any Expo Router API routes bundled alongside it. This skill covers deploying a website, authoring API routes, and the hosting runtime; see the Deployment section below for the deploy workflow.

When to Use API Routes

Use API routes when you need:

  • Server-side secrets — API keys, database credentials, or tokens that must never reach the client
  • Database operations — Direct database queries that shouldn't be exposed
  • Third-party API proxies — Hide API keys when calling external services (OpenAI, Stripe, etc.)
  • Server-side validation — Validate data before database writes
  • Webhook endpoints — Receive callbacks from services like Stripe or GitHub
  • Rate limiting — Control access at the server level
  • Heavy computation — Offload processing that would be slow on mobile

When NOT to Use API Routes

Avoid API routes when:

  • Data is already public — Use direct fetch to public APIs instead
  • No secrets required — Static data or client-safe operations
  • Real-time updates needed — Use WebSockets or services like Supabase Realtime
  • Simple CRUD — Consider Firebase, Supabase, or Convex for managed backends
  • File uploads — Use direct-to-storage uploads (S3 presigned URLs, Cloudflare R2)
  • Authentication only — Use Clerk, Auth0, or Firebase Auth instead

File Structure

API routes live in the app directory with +api.ts suffix:

app/
  api/
    hello+api.ts          → GET /api/hello
    users+api.ts          → /api/users
    users/[id]+api.ts     → /api/users/:id
  (tabs)/
    index.tsx

Basic API Route

ts
// app/api/hello+api.ts
export function GET(request: Request) {
  return Response.json({ message: "Hello from Expo!" });
}

HTTP Methods

Export named functions for each HTTP method:

ts
// app/api/items+api.ts
export function GET(request: Request) {
  return Response.json({ items: [] });
}

export async function POST(request: Request) {
  const body = await request.json();
  return Response.json({ created: body }, { status: 201 });
}

export async function PUT(request: Request) {
  const body = await request.json();
  return Response.json({ updated: body });
}

export async function DELETE(request: Request) {
  return new Response(null, { status: 204 });
}

Dynamic Routes

ts
// app/api/users/[id]+api.ts
export function GET(request: Request, { id }: { id: string }) {
  return Response.json({ userId: id });
}

Request Handling

Query Parameters
ts
export function GET(request: Request) {
  const url = new URL(request.url);
  const page = url.searchParams.get("page") ?? "1";
  const limit = url.searchParams.get("limit") ?? "10";

  return Response.json({ page, limit });
}
Headers
ts
export function GET(request: Request) {
  const auth = request.headers.get("Authorization");

  if (!auth) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }

  return Response.json({ authenticated: true });
}
JSON Body
ts
export async function POST(request: Request) {
  const { email, password } = await request.json();

  if (!email || !password) {
    return Response.json({ error: "Missing fields" }, { status: 400 });
  }

  return Response.json({ success: true });
}

Environment Variables

Use process.env for server-side secrets:

ts
// app/api/ai+api.ts
export async function POST(request: Request) {
  const { prompt } = await request.json();

  const response = await fetch("https://api.openai.com/v1/chat/completions", {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
    },
    body: JSON.stringify({
      model: "gpt-4",
      messages: [{ role: "user", content: prompt }],
    }),
  });

  const data = await response.json();
  return Response.json(data);
}

Set environment variables:

  • Local: Create .env file (never commit)
  • EAS Hosting: Use eas env:create or Expo dashboard

CORS Headers

Add CORS for web clients:

ts
const corsHeaders = {
  "Access-Control-Allow-Origin": "*",
  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
  "Access-Control-Allow-Headers": "Content-Type, Authorization",
};

export function OPTIONS() {
  return new Response(null, { headers: corsHeaders });
}

export function GET() {
  return Response.json({ data: "value" }, { headers: corsHeaders });
}

Error Handling

ts
export async function POST(request: Request) {
  try {
    const body = await request.json();
    // Process...
    return Response.json({ success: true });
  } catch (error) {
    console.error("API error:", error);
    return Response.json({ error: "Internal server error" }, { status: 500 });
  }
}

Testing Locally

Start the development server with API routes:

bash
npx expo serve

This starts a local server at http://localhost:8081 with full API route support.

Test with curl:

bash
curl http://localhost:8081/api/hello
curl -X POST http://localhost:8081/api/users -H "Content-Type: application/json" -d '{"name":"Test"}'

Deployment to EAS Hosting

Prerequisites
bash
npm install -g eas-cli
eas login
Deploy

Deploying ships your web bundle and any Expo Router API routes together - eas deploy handles both. The export runs whether you have a full website, an API-routes-only backend, or both.

bash
# Export the web bundle (includes any API routes)
npx expo export -p web

# Deploy a preview (PR-style URL)
npx eas-cli@latest deploy

# Deploy to production
npx eas-cli@latest deploy --prod

Everything lands on EAS Hosting (Cloudflare Workers).

Environment Variables for Production
bash
# Create a secret
eas env:create --name OPENAI_API_KEY --value sk-xxx --environment production

# Or use the Expo dashboard
Show full SKILL.md (276 more words)Show less
Custom Domain

Configure in eas.json or Expo dashboard.

Automate with EAS Workflows

Deploy the website (and API routes) on every push to main with a type: deploy workflow:

.eas/workflows/deploy.yml

yaml
name: Deploy

on:
  push:
    branches:
      - main

# https://docs.expo.dev/eas/workflows/syntax/#deploy
jobs:
  deploy_web:
    type: deploy
    params:
      prod: true

Preview deploys for pull requests use the same job type with prod: false:

yaml
name: Web PR Preview

on:
  pull_request:
    types: [opened, synchronize]

jobs:
  preview:
    type: deploy
    params:
      prod: false

To author or validate workflow YAML beyond these examples, use the eas-workflows skill.

EAS Hosting Runtime (Cloudflare Workers)

API routes run on Cloudflare Workers. Key limitations:

Missing/Limited APIs
  • No Node.js filesystem — fs module unavailable
  • No native Node modules — Use Web APIs or polyfills
  • Limited execution time — 30 second timeout for CPU-intensive tasks
  • No persistent connections — WebSockets require Durable Objects
  • fetch is available — Use standard fetch for HTTP requests
Use Web APIs Instead
ts
// Use Web Crypto instead of Node crypto
const hash = await crypto.subtle.digest(
  "SHA-256",
  new TextEncoder().encode("data")
);

// Use fetch instead of node-fetch
const response = await fetch("https://api.example.com");

// Use Response/Request (already available)
return new Response(JSON.stringify(data), {
  headers: { "Content-Type": "application/json" },
});
Database Options

Since filesystem is unavailable, use cloud databases:

  • Cloudflare D1 — SQLite at the edge
  • Turso — Distributed SQLite
  • PlanetScale — Serverless MySQL
  • Supabase — Postgres with REST API
  • Neon — Serverless Postgres

Example with Turso:

ts
// app/api/users+api.ts
import { createClient } from "@libsql/client/web";

const db = createClient({
  url: process.env.TURSO_URL!,
  authToken: process.env.TURSO_AUTH_TOKEN!,
});

export async function GET() {
  const result = await db.execute("SELECT * FROM users");
  return Response.json(result.rows);
}

Calling API Routes from Client

ts
// From React Native components
const response = await fetch("/api/hello");
const data = await response.json();

// With body
const response = await fetch("/api/users", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ name: "John" }),
});

Common Patterns

Authentication Middleware
ts
// utils/auth.ts
export async function requireAuth(request: Request) {
  const token = request.headers.get("Authorization")?.replace("Bearer ", "");

  if (!token) {
    throw new Response(JSON.stringify({ error: "Unauthorized" }), {
      status: 401,
      headers: { "Content-Type": "application/json" },
    });
  }

  // Verify token...
  return { userId: "123" };
}

// app/api/protected+api.ts
import { requireAuth } from "../../utils/auth";

export async function GET(request: Request) {
  const { userId } = await requireAuth(request);
  return Response.json({ userId });
}
Proxy External API
ts
// app/api/weather+api.ts
export async function GET(request: Request) {
  const url = new URL(request.url);
  const city = url.searchParams.get("city");

  const response = await fetch(
    `https://api.weather.com/v1/current?city=${city}&key=${process.env.WEATHER_API_KEY}`
  );

  return Response.json(await response.json());
}

Rules

  • NEVER expose API keys or secrets in client code
  • ALWAYS validate and sanitize user input
  • Use proper HTTP status codes (200, 201, 400, 401, 404, 500)
  • Handle errors gracefully with try/catch
  • Keep API routes focused — one responsibility per endpoint
  • Use TypeScript for type safety
  • Log errors server-side for debugging

Submitting Feedback

If you encounter errors, misleading or outdated information in this skill, report it so Expo can improve:

bash
npx --yes submit-expo-feedback@latest --category skills --subject "eas-hosting" "<actionable feedback>"

Only submit when you have something specific and actionable to report. Include as much relevant context as possible. If an AI agent repeatedly failed or the user had to take over an Expo task, load the expo-skill-feedback skill and follow its eval-candidate flow instead of reusing the command above.

© expo, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 1 other file in plugins/expo/skills/eas-hosting of expo/skills.

  • SKILL.md
  • agents/openai.yaml

Open the folder on GitHubat commit d4f4840

Used in 2 other repositories

We found 6 copies of this SKILL.md (exact, near-identical or edited) in other folders, from 2 other GitHub owners. This page covers the copy in expo/skills, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Eas Hosting next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Eas Hosting compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Eas Hosting this skillexpo/skills2.7k2 repos~2.9kAutomated safety check: NotesMIT
App Store Reviewsafaiyeh/app-store-review-skill3611 repos~3.4kAutomated safety check: PassMIT
Expo Deploymentkingstinct/react-native-healthkit7154 repos~930Automated safety check: PassMIT
Expo Dev Clientkingstinct/react-native-healthkit7155 repos~879Automated safety check: PassMIT
Expo API Routesadrianhajdin/react-native-lingua1506 repos~2.2kAutomated safety check: NotesMIT
Iapkit E2E Martiehyodotdev/openiap154—~5.4kAutomated safety check: NotesMIT

Similar skills

  • App Store Review

    safaiyeh/app-store-review-skill

    Evaluates code against Apple's App Store Review Guidelines. An agent skill from safaiyeh/app-store-review-skill.

    361 GitHub starsUsed in 1 repo~3.4k tokens
    MobileAuto-check passed
  • Expo Deployment

    kingstinct/react-native-healthkit

    Deploying Expo apps to iOS App Store, Android Play Store, web hosting, and API routes

    715 GitHub starsUsed in 4 repos~930 tokens
    MobileAuto-check passed
  • Expo Dev Client

    kingstinct/react-native-healthkit

    Build and distribute Expo development clients locally or via TestFlight

    715 GitHub starsUsed in 5 repos~879 tokens
    MobileAuto-check passed
  • Expo API Routes

    adrianhajdin/react-native-lingua

    Guidelines for creating API routes in Expo Router with EAS Hosting

    150 GitHub starsUsed in 6 repos~2.2k tokens
    MobileAuto-check: notes
  • Iapkit E2E Martie

    hyodotdev/openiap

    Run IAPKit local receipt-validation E2E with the dev.hyo.martie React Native or Expo examples, the compiled packages/kit server, real Convex, and Apple or Google sandbox purchases.

    154 GitHub stars~5.4k tokensUpdated yesterday
    MobileAuto-check: notes
  • Eas App Stores

    sickn33/agentic-awesome-skills

    Curated upstream guidance for Eas App Stores; use when the workflow matches the user goal.

    47k GitHub starsUsed in 1 repo~1.9k tokens
    MobileAuto-check passed

More from expo/skills

All 26 skills in this repo
  • Official

    Check the health of published EAS Update: crash rates, install/launch counts, unique users, payload size, and the split between embedded and OTA users per channel.

    2.7k GitHub starsUsed in 4 repos~3.1k tokens
    Auto-check passed
  • Eas Workflows

    expo/skills

    Official

    Helps understand and write EAS workflow YAML files for Expo projects.

    2.7k GitHub stars~1.2k tokensUpdated today
    Auto-check passed
  • Expo App Clip

    expo/skills

    Official

    Add an iOS App Clip target to an Expo app. An agent skill from expo/skills.

    2.7k GitHub starsUsed in 2 repos~2.4k tokens
    Auto-check passed
  • Expo Skill Eval

    expo/skills

    Official

    Evaluate Expo skills in this repo end-to-end - trigger accuracy, generated code quality, and runtime screenshots on iOS simulator and Android emulator via Expo Go (web optional).

    2.7k GitHub stars~12k tokensUpdated today
    Auto-check passed
  • Official

    Submit feedback on an Expo skill—or Expo itself—and control bundled anonymous usage telemetry (off by default / opt-in).

    2.7k GitHub stars~1.3k tokensUpdated today
    Auto-check passed
  • Expo Module

    expo/skills

    Official

    Guide for creating and writing Expo native modules and views using the Expo Modules API (Swift, Kotlin, TypeScript).

    2.7k GitHub starsUsed in 1 repo~1.6k tokens
    Auto-check passed

Categories

Questions about Eas Hosting

What does Eas Hosting do?

Deploy Expo websites and Expo Router API routes to EAS Hosting - export the web bundle, run eas deploy for production and PR preview URLs, manage environment secrets and custom domains, and work…. Eas Hosting is an agent skill from expo/skills, published by the product's own GitHub organization. Deploy Expo websites and Expo Router API routes to EAS Hosting - export the web bundle, run eas deploy for production and PR preview URLs, manage environment secrets and custom domains, and work within the Cloudflare Workers runtime.

When should I use Eas Hosting?

Eas Hosting fits situations like: deploying an Expo web app; setting up EAS Hosting; configuring hosting environments and domains.

How do I install Eas Hosting in Claude Code?

Run `npx skills add expo/skills --skill eas-hosting -a claude-code`. Or copy the skill folder (plugins/expo/skills/eas-hosting in expo/skills) into .claude/skills/eas-hosting in your project. Claude Code loads it when a task matches its description.

How do I install Eas Hosting in Codex?

Run `npx skills add expo/skills --skill eas-hosting -a codex`. Or copy the skill folder (plugins/expo/skills/eas-hosting in expo/skills) into .agents/skills/eas-hosting in your project. Codex loads it when a task matches its description.

Can I use Eas Hosting in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add expo/skills --skill eas-hosting -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/eas-hosting, .gemini/skills/eas-hosting, .github/skills/eas-hosting and .opencode/skills/eas-hosting in your project.

What does Eas Hosting need to run?

Going by SKILL.md and its folder, Eas Hosting needs the command-line tools its instructions call (npx, eas, curl and npm) and credentials named OPENAI_API_KEY, TURSO_AUTH_TOKEN and WEATHER_API_KEY. Our summary lists: Node.js; A credential in OPENAI_API_KEY; A credential in TURSO_AUTH_TOKEN.

Does Eas Hosting access the network?

SKILL.md names 4 domains. In commands or code: api.openai.com, docs.expo.dev and api.weather.com; the agent is likely to contact these when it follows the instructions. As links in the text: expo.dev. This is read from the text; nothing was executed.

Is Eas Hosting safe to install?

Our automated static check of SKILL.md found notes only (mentions a .env file), nothing it rates as a warning. It is not a guarantee. Review the folder before installing.

What licence does Eas Hosting use?

Eas Hosting is published under the MIT licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Eas Hosting use?

About 2.9k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Eas Hosting?

Skills that share tags, products or a category with Eas Hosting: App Store Review (safaiyeh/app-store-review-skill, 361 stars), Expo Deployment (kingstinct/react-native-healthkit, 715 stars), Expo Dev Client (kingstinct/react-native-healthkit, 715 stars) and Expo API Routes (adrianhajdin/react-native-lingua, 150 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Eas Hosting?

expo (a GitHub organization, an official publisher) maintains it in expo/skills, which has 2,661 GitHub stars. The repository holds 26 skills in this directory. The repository was last updated on October 6, 2026.

Source: expo/skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.