> ## Documentation Index
> Fetch the complete documentation index at: https://docs.base.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Migrate to a Standard Web App

> Migrate your Farcaster mini-app to work in the Base App. Covers replacing deprecated SDK methods, and registering on Base.dev.

<Warning>
  After April 9, 2026, the Base App treats all apps as standard web apps regardless of Farcaster manifests. Use the migration paths below to get your app working correctly in the Base App.
</Warning>

<Tip>
  **Using an AI coding agent?** Install the [Migration Skill](https://github.com/base/skills) to let your agent handle this migration automatically. Run `npx skills add base/skills` and ask your agent to migrate your Farcaster app to a standard web app.
</Tip>

## What's changing

The Base App is moving from the Farcaster mini-app spec to a single model: **standard web app + wallet**, powered by Base.dev.

| Before                                             | After                                                                                                              |
| -------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------ |
| Farcaster manifest (`/.well-known/farcaster.json`) | App metadata on [Base.dev](https://www.base.dev) projects. Already registered apps do not need to update metadata. |
| Neynar webhooks for add/remove events              | Base-owned backends (Base Account / address preferences)                                                           |
| FID-based notifications via Neynar                 | Wallet-address notifications via Base.dev notifications API *(coming soon)*                                        |
| Farcaster SDK for auth and actions                 | wagmi + viem + Sign-In with Ethereum (SIWE)                                                                        |
| Search and discovery via Farcaster                 | Base.dev app metadata + [builder codes](https://docs.base.org/apps/builder-codes/builder-codes)                    |

***

## Choose your migration path

<Tabs>
  <Tab title="I'm converting an app">
    <Tip>
      **Let your agent handle this.** Install the [Migration Skill](https://github.com/base/skills) with `npx skills add base/skills` and ask your agent to migrate your Farcaster app to a standard web app. The skill maps deprecated SDK methods, replaces auth and wallet logic, and wires up the Base App path automatically.
    </Tip>

    Your app uses the Farcaster SDK. The migration replaces Farcaster-specific auth, identity, and actions with standard web equivalents.

    <Steps>
      <Step title="Add the standard web stack">
        Install wagmi, viem, and React Query if you don't have them already:

        ```bash Terminal theme={null}
        npm install wagmi viem @tanstack/react-query @base-org/account
        ```

        Create a wagmi config for Base and wrap your app with `WagmiProvider` and `QueryClientProvider`:

        ```tsx config.ts lines expandable wrap theme={null}
        import { http, createConfig, createStorage, cookieStorage } from 'wagmi';
        import { base } from 'wagmi/chains';
        import { baseAccount, injected } from 'wagmi/connectors';

        export const config = createConfig({
          chains: [base],
          connectors: [
            injected(),
            baseAccount({
              appName: 'My App',
            }),
          ],
          storage: createStorage({ storage: cookieStorage }),
          ssr: true,
          transports: {
            [base.id]: http(),
          },
        });

        declare module 'wagmi' {
          interface Register {
            config: typeof config;
          }
        }
        ```

        ```tsx App.tsx lines highlight={8-12} theme={null}
        import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
        import { WagmiProvider } from 'wagmi';
        import { config } from './config';

        const queryClient = new QueryClient();

        export default function App({ children }: { children: React.ReactNode }) {
          return (
            <WagmiProvider config={config}>
              <QueryClientProvider client={queryClient}>
                {children}
              </QueryClientProvider>
            </WagmiProvider>
          );
        }
        ```

        This replaces the Farcaster frame connector with standard wagmi providers that work in the Base app's in-app browser.
      </Step>

      <Step title="Replace auth and identity">
        Farcaster sign-in and FID-based identity are not available in the Base App. Replace them with [SIWE](https://viem.sh/docs/siwe/utilities/createSiweMessage) for authentication and the connected wallet address for user identity.

        Build, sign, and verify the SIWE message:

        ```tsx SignIn.tsx lines expandable wrap highlight={1,9,14-18,33-34} theme={null}
        'use client';

        import { useState } from 'react';
        import { createSiweMessage, generateSiweNonce } from 'viem/siwe';
        import { useAccount, usePublicClient, useSignMessage } from 'wagmi';

        export function SignIn() {
          const { address, chainId, isConnected } = useAccount();
          const [isSigningIn, setIsSigningIn] = useState(false);
          const { signMessageAsync } = useSignMessage();
          const publicClient = usePublicClient();

          async function handleSignIn() {
            if (!isConnected || !address || !chainId || !publicClient) {
              throw new Error('Connect your wallet before signing in');
            }

            setIsSigningIn(true);
            const nonce = generateSiweNonce();

            try {
              const message = createSiweMessage({
                address,
                chainId,
                domain: window.location.host,
                nonce,
                uri: window.location.origin,
                version: '1',
              });

              const signature = await signMessageAsync({ message });

              const valid = await publicClient.verifySiweMessage({ message, signature });
              if (!valid) throw new Error('SIWE verification failed');
            } finally {
              setIsSigningIn(false);
            }
          }

          return (
            <button
              type="button"
              onClick={handleSignIn}
              disabled={!isConnected || isSigningIn}
            >
              {isSigningIn ? 'Signing in...' : 'Sign in with Ethereum'}
            </button>
          );
        }
        ```

        <Note>
          This example verifies the signature client-side. If your app needs server-side sessions or replay protection, see the [Authenticate users](/base-account/guides/authenticate-users) guide for the full pattern with server-issued nonces, backend verification.
        </Note>

        Use `useAccount` from wagmi to read the connected wallet address as the user's identity and guard SIWE execution until the wallet and chain are available.
      </Step>

      <Step title="Review SDK method compatibility">
        See the [compatibility table](#deprecated-farcaster-sdk-methods-in-the-base-app) for what will and won't work in the Base app, along with standard web alternatives.
      </Step>

      <Step title="Migrate notifications to Base.dev">
        <Warning>
          Notifications migration will be available in Base.dev soon.
        </Warning>

        Farcaster-based notifications (via Neynar, FIDs, or tokens) will not reach Base App users. Replace them with the Base.dev notifications API, which sends by wallet address.
      </Step>

      <Step title="Register on Base.dev">
        If you haven't registered yet, create a project at [Base.dev](https://www.base.dev) and complete your app metadata: name, icon, tagline, description, screenshots, category, primary URL, and [builder code](/apps/builder-codes/builder-codes). Already registered apps do not need to re-register or update metadata.
      </Step>
    </Steps>
  </Tab>

  <Tab title="My app has no Farcaster SDK">
    Your app is already a standard web app. You're mostly done — just verify your stack and register on Base.dev.

    <Steps>
      <Step title="Confirm your app is web- and wallet-ready">
        * Loads in a mobile browser (the Base App uses a standard in-app browser)
        * Uses wagmi/viem for wallet connection and contract interactions
        * Uses [SIWE](https://viem.sh/docs/siwe/utilities/createSiweMessage) for authentication where needed
      </Step>

      <Step title="Register on Base.dev">
        If you haven't registered yet, create a project at [Base.dev](https://www.base.dev) and complete your app metadata: name, icon, tagline, description, screenshots, category, primary URL, and [builder code](/apps/builder-codes/builder-codes). Already registered apps do not need to re-register or update metadata.
      </Step>

      <Step title="Integrate notifications (optional)">
        <Warning>
          Notifications migration will be available in Base.dev soon.
        </Warning>

        Use the Base.dev notifications API to send wallet-address notifications to users who installed your app and opted in.
      </Step>
    </Steps>

    <Check>
      Your app is ready for the Base App — no Farcaster manifest required.
    </Check>
  </Tab>
</Tabs>

***

## Deprecated Farcaster SDK methods in the Base App

The following Farcaster mini-app SDK methods are not invoked by the Base App after April 9, 2026. Migrate to the alternatives listed.

| SDK method                         | Alternative in the Base App                                                                                   |
| ---------------------------------- | ------------------------------------------------------------------------------------------------------------- |
| `signIn`                           | [Sign-In with Ethereum](https://viem.sh/docs/siwe/utilities/createSiweMessage) using wagmi (`useSignMessage`) |
| `sendToken`                        | Standard ERC-20 transfer with wagmi (`useWriteContract`)                                                      |
| `openUrl`                          | `window.open(url)`                                                                                            |
| `openMiniApp`                      | `window.open(url)`                                                                                            |
| `viewToken`                        | Deeplink: `https://base.app/coin/base-mainnet/TOKEN_ADDRESS`                                                  |
| `viewProfile`                      | Deeplink: `https://base.app/profile/WALLET_ADDRESS`                                                           |
| `swapToken`                        | Construct swap transactions with wagmi, viem, or your preferred onchain library.                              |
| `requestCameraAndMicrophoneAccess` | No replacement                                                                                                |
| `close`                            | No replacement                                                                                                |
| `addMiniApp`                       | the Base App handles app installation automatically. No SDK needed.                                           |
| `viewCast`                         | Not needed in the Base App                                                                                    |
| `composeCast`                      | Not needed in the Base App                                                                                    |
| `ready`                            | Not needed. Your app is ready to display when it loads.                                                       |
| User context and FID               | Read the injected wallet address via wagmi (`useAccount`)                                                     |

## Pre-flight checklist

Before considering your app migrated, verify the following:

<Steps>
  <Step title="Wallet and auth use wagmi + viem">
    Wallet connection and contract interactions use wagmi + viem. Authentication uses [SIWE](https://viem.sh/docs/siwe/utilities/createSiweMessage) where needed.
  </Step>

  <Step title="Register and complete Base.dev metadata">
    Project is registered on [Base.dev](https://www.base.dev) with primary URL set. Name, icon, tagline, screenshots, category, description, and [builder code](/apps/builder-codes/builder-codes) are all filled in.
  </Step>

  <Step title="Notifications use Base.dev API (if applicable)">
    <Warning>
      Notifications migration will be available in Base.dev soon.
    </Warning>

    Notifications are sent via the Base.dev notifications API by wallet address — not via Neynar, FIDs, or tokens.
  </Step>
</Steps>

<Check>
  If all steps above are complete, your app is ready for the Base App as a standard web app.
</Check>