diff --git a/docs/mini-apps/quickstart/migrate-existing-apps.mdx b/docs/mini-apps/quickstart/migrate-existing-apps.mdx
index e2b3d2c1b..ca03fa1dd 100644
--- a/docs/mini-apps/quickstart/migrate-existing-apps.mdx
+++ b/docs/mini-apps/quickstart/migrate-existing-apps.mdx
@@ -3,6 +3,13 @@ hidden: true
 title: Migrate an Existing App
 description: Quickly migrate your existing app to a mini app, preview it in Base Build, and publish to the Base app.
 ---
+
+<Warning>
+**Deprecated:** This guide is for the legacy Mini App flow using Farcaster manifests. As of April 9, 2026, the Base App treats all apps as standard web apps. 
+
+**For most developers:** Use the [Migrate to a Standard Web App](/mini-apps/quickstart/migrate-to-standard-web-app) guide instead. You only need this legacy flow if you specifically require Farcaster integration (frames, cast actions, etc.).
+</Warning>
+
 <Panel>
 <iframe
   className="w-3/4 aspect-video rounded-xl mx-auto block"
@@ -74,168 +81,75 @@ Create a file available at `https://www.your-domain.com/.well-known/farcaster.js
 <Tabs>
     <Tab title="Vanilla JS">
     Create the manifest file in your project at `/public/.well-known/farcaster.json`.
-    </Tab>
+    ω/Tab>
     <Tab title="Next.js">
-    Create a Next.js route to host your manifest file
-    ```typescript app/.well-known/farcaster.json/route.ts
-    function withValidProperties(properties: Record<string, undefined | string | string[]>) {
-    return Object.fromEntries(
-        Object.entries(properties).filter(([_, value]) => (Array.isArray(value) ? value.length > 0 : !!value))
-    );
-    }
-
-    export async function GET() {
-    const URL = process.env.NEXT_PUBLIC_URL as string;
-    return Response.json(paste_manifest_json_object_here); // see the next step for the manifest_json_object
-    }
-    ```
+    Create the manifest file in your project at `/public/.well-known/farcaster.json`.
     </Tab>
 </Tabs>
 
-</Step>
-
-<Step title="Update the Manifest">
-Copy the example manifest below and add it to the file created in the previous step. Update each field in the `miniapp`.
-
-For details on each field, see the [field reference](/mini-apps/features/manifest#field-reference)
+The manifest file should contain the following:
 
-### Example Manifest
-```json /.well-known/farcaster.json
+```json
 {
-  "accountAssociation": {  // these will be added in step 5
-    "header": "",
-    "payload": "",
-    "signature": ""
+  "accountAssociation": {
+    "header": "eyJmaWQiOjE1Njk0LCJ0eXBlIjoiY3VzdG9keSIsImtleSI6IjB4NTR...",
+    "payload": "eyJkb21haW4iOiJleGFtcGxlLmNvbSJ9",
+    "signature": "MHg5ZjI5ZDIzMzUzZjE2Y2Y1ZTVkYjIwN2YxZTBiMzA0..."
   },
-  "miniapp": {
-    "version": "1",
-    "name": "Example Mini App",
-    "homeUrl": "https://ex.co",
-    "iconUrl": "https://ex.co/i.png",
-    "splashImageUrl": "https://ex.co/l.png",
+  "frame": {
+    "version": "next",
+    "name": "Example App",
+    "iconUrl": "https://example.com/icon.png",
+    "homeUrl": "https://example.com",
+    "imageUrl": "https://example.com/image.png",
+    "buttonTitle": "Launch",
+    "splashImageUrl": "https://example.com/splash.png",
     "splashBackgroundColor": "#000000",
-    "webhookUrl": "https://ex.co/api/webhook",
-    "subtitle": "Fast, fun, social",
-    "description": "A fast, fun way to challenge friends in real time.",
-    "screenshotUrls": [
-      "https://ex.co/s1.png",
-      "https://ex.co/s2.png",
-      "https://ex.co/s3.png"
-    ],
-    "primaryCategory": "social",
-    "tags": ["example", "miniapp", "baseapp"],
-    "heroImageUrl": "https://ex.co/og.png",
-    "tagline": "Play instantly",
-    "ogTitle": "Example Mini App",
-    "ogDescription": "Challenge friends in real time.",
-    "ogImageUrl": "https://ex.co/og.png",
-    "noindex": true
+    "webhookUrl": "https://example.com/api/webhook"
   }
 }
 ```
-</Step>
-
-<Step title="Create accountAssociation Credentials">
-The `accountAssociation` fields in the manifest are used to verify ownership of your app. You can generate these fields on Base Build.
-
-
-    1. Ensure all changes are live so that the Manifest file is available at your app's url.
-    2. Navigate to the Base Build [Account association tool](https://www.base.dev/preview?tab=account). 
-    3. Paste your domain in the `App URL` field (ex: sample-url.vercel.app) and click "Submit"
-    4. Click on the "Verify" button that appears and follow the instructions to generate the `accountAssociation` fields.
-    5. Copy the `accountAssociation` fields and paste them into the manifest file you added in the previous step.
-    ```json /.well-known/farcaster.json
-    {
-      "accountAssociation": {
-        "header": "eyJmaWQiOjkxNTIsInR5cGUiOiJjdXN0b2R5Iiwia2V5IjoiMHgwMmVmNzkwRGQ3OTkzQTM1ZkQ4NDdDMDUzRURkQUU5NDBEMDU1NTk2In0",
-        "payload": "eyJkb21haW4iOiJhcHAuZXhhbXBsZS5jb20ifQ",
-        "signature": "MHgwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDIwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwNDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAyMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwYzAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMTIwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAxNzAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDEyNDdhNDhlZGJmMTMwZDU0MmIzMWQzZTg1ZDUyOTAwMmEwNDNkMjM5NjZiNWVjNTNmYjhlNzUzZmIyYzc1MWFmNTI4MWFiYTgxY2I5ZDE3NDAyY2YxMzQxOGI2MTcwYzFiODY3OTExZDkxN2UxMzU3MmVkMWIwYzNkYzEyM2Q1ODAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMjVmMTk4MDg2YjJkYjE3MjU2NzMxYmM0NTY2NzNiOTZiY2VmMjNmNTFkMWZiYWNkZDdjNDM3OWVmNjU0NjU1NzJmMWQwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwOGE3YjIyNzQ3OTcwNjUyMjNhMjI3NzY1NjI2MTc1NzQ2ODZlMmU2NzY1NzQyMjJjMjI2MzY4NjE2YzZjNjU2ZTY3NjUyMjNhMjI2NDJkMzQ0YjMzMzMzNjUyNDY3MDc0MzE0NTYxNjQ2Yjc1NTE0ODU3NDg2ZDc5Mzc1Mzc1Njk2YjQ0MzI0ZjM1NGE2MzRhNjM2YjVhNGM3NDUzMzczODIyMmMyMjZmNzI2OTY3Njk2ZTIyM2EyMjY4NzQ3NDcwNzMzYTJmMmY2YjY1Nzk3MzJlNjM2ZjY5NmU2MjYxNzM2NTJlNjM2ZjZkMjIyYzIyNjM3MjZmNzM3MzRmNzI2OTY3Njk2ZTIyM2E2NjYxNmM3MzY1N2QwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMA"
-      },
-      "miniapp": {...} // these fields remain the same
-    }
-    ```
-    <Info>
-    Note: Because you are signing with your Base Account, the `signature` field will be significantly longer than if you were to sign directly with your Farcaster custody wallet. 
-    </Info>
 
+To generate the `accountAssociation` fields, use the [Farcaster Account Association tool](https://farcaster.xyz/~/developers/mini-apps/account-association).
 </Step>
 
-<Step title="Add Embed Metadata">
-  Update your index.html file to include the `fc:miniapp` metadata. This is used to generate the rich embeds when your app is shared and is required for your app to display.
+<Step title="Verify the Manifest">
+Ensure your manifest is accessible at the correct URL:
 
-  <Tabs>
-    <Tab title="Vanilla JS">
-    Add directly to your index.html file.
-  ```html index.html
-    <meta name="fc:miniapp" content='{
-    "version":"next",
-    "imageUrl":"https://your-app.com/embed-image",
-    "button":{
-        "title":"Play Now",
-        "action":{
-        "type":"launch_miniapp",
-        "name":"Your App Name",
-        "url":"https://your-app.com"
-        }
-    }
-    }' />
-    ```
-    </Tab>
-    <Tab title="Next.js">
-    Use the `generateMetadata` function to add the `fc:miniapp` metadata.
-    ```typescript app/layout.tsx
-        export async function generateMetadata(): Promise<Metadata> {
-        return {
-            other: {
-            'fc:miniapp': JSON.stringify({
-                version: 'next',
-                imageUrl: 'https://your-app.com/embed-image',
-                button: {
-                    title: `Launch Your App Name`,
-                    action: {
-                        type: 'launch_miniapp',
-                        name: 'Your App Name',
-                        url: 'https://your-app.com',
-                        splashImageUrl: 'https://your-app.com/splash-image',
-                        splashBackgroundColor: '#000000',
-                    },
-                },
-            }),
-            },
-        };
-        }
-    ```
-    </Tab>
-</Tabs>
-</Step>
-<Step title="Push to Production">
-  Ensure all changes are live.
+```
+https://www.your-domain.com/.well-known/farcaster.json
+```
+
+The file should be publicly accessible and return valid JSON.
 </Step>
 
-<Step title="Preview Your App">
-  Use the Base Build [Preview tool](https://www.base.dev/preview) to validate your app.
-  1. Add your app URL to view the embeds and click the launch button to verify the app launches as expected. 
-  2. Use the "Account association" tab to verify the association credentials were created correctly.
-  3. Use the "Metadata" to see the metadata added from the manifest and identify any missing fields.
-
-  <video
-  autoPlay
-  muted
-  loop
-  playsInline
-  src="/videos/mini-apps/basebuildpreview.mp4"
-></video>
+<Step title="Register on Base.dev">
+1. Go to [Base.dev](https://www.base.dev)
+2. Sign in with your account
+3. Click "Add Project"
+4. Enter your app details and domain
+5. Verify ownership (the manifest file helps with this)
 </Step>
-<Step title="Post to Publish">
-    To publish your app, create a post in the Base app with your app's URL.
 
+<Step title="Import as Mini App">
+After registering on Base.dev:
 
-    <img 
-  src="/images/minikit/publish-app-base.png" 
-  alt="Posting an app to Base app"
-  height="300"
-  className="rounded-lg"
-    />
+1. Go to your project dashboard
+2. Click "Import Mini App"
+3. Enter your domain
+4. The system will verify your manifest file
+5. Once verified, your app will be available in the Base App
 </Step>
 </Steps>
 
+---
+
+## Alternative: Standard Web App Flow
+
+If you don't need Farcaster-specific features (frames, cast actions, etc.), consider using the [standard web app flow](/mini-apps/quickstart/migrate-to-standard-web-app) instead. This is the recommended approach for most apps as of April 9, 2026.
+
+The standard web app flow:
+- Does not require a Farcaster manifest
+- Uses wagmi/viem for wallet connection instead of the MiniApp SDK
+- Works with any standard web app
+- Is simpler to implement and maintain
diff --git a/docs/mini-apps/quickstart/migrate-to-standard-web-app.mdx b/docs/mini-apps/quickstart/migrate-to-standard-web-app.mdx
index 0c8e5ca68..8cab6ad76 100644
--- a/docs/mini-apps/quickstart/migrate-to-standard-web-app.mdx
+++ b/docs/mini-apps/quickstart/migrate-to-standard-web-app.mdx
@@ -12,6 +12,20 @@ After April 9, 2026, the Base App treats all apps as standard web apps regardles
 **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 mini app to a standard web app.
 </Tip>
 
+## Which migration path should I use?
+
+Choose the right path based on your current app setup and goals:
+
+| If you... | Use this path | Farcaster manifest required? |
+| --- | --- | --- |
+| Have an existing Farcaster mini app using the MiniApp SDK | ["I'm converting a mini app"](#choose-your-migration-path) below | No |
+| Have a standard web app (not a mini app) and want to add it to Base App | [Register on Base.dev](https://www.base.dev) directly | No |
+| Need Farcaster-specific features (frames, casts, etc.) | [Legacy Mini App flow](/mini-apps/quickstart/migrate-existing-apps) (deprecated) | Yes |
+
+**Key point:** As of April 9, 2026, the Base App treats all apps as standard web apps. The Farcaster manifest and "Import Mini App" flow are only needed if you specifically require Farcaster integration (frames, cast actions, etc.). For most apps, simply registering on Base.dev is sufficient.
+
+---
+
 ## 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.
@@ -34,230 +48,180 @@ The Base App is moving from the Farcaster mini-app spec to a single model: **sta
 **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 mini 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.
+Your app uses the Farcaster SDK. The migration replaces Farcaster-specific auth, identity, and actions with standard web patterns.
 
+<Steps>
+<Step title="Remove the MiniApp SDK">
+Uninstall the Farcaster SDK packages:
+
+<CodeGroup>
+```bash npm
+npm uninstall @farcaster/miniapp-sdk
+```
+
+```bash pnpm
+pnpm remove @farcaster/miniapp-sdk
+```
+
+```bash yarn
+yarn remove @farcaster/miniapp-sdk
+```
+</CodeGroup>
+</Step>
 
+<Step title="Add wallet connection">
+Install wagmi and viem for wallet connection:
 
-<Steps>
+<CodeGroup>
+```bash npm
+npm install wagmi viem
+```
 
-<Step title="Add the standard web stack">
-  Install wagmi, viem, and React Query if you don't have them already:
-
-  ```bash Terminal
-  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
-  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}
-  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>
+```bash pnpm
+pnpm add wagmi viem
+```
+
+```bash yarn
+yarn add wagmi viem
+```
+</CodeGroup>
 
-<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}
-  '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.
+<Note>
+If your app is already using wagmi/viem for wallet connection, you can skip this step.
+</Note>
 </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 title="Replace auth with SIWE">
+Replace Farcaster-specific auth with Sign-In with Ethereum (SIWE):
+
+**Before (Farcaster SDK):**
+```typescript
+import { sdk } from '@farcaster/miniapp-sdk';
+
+// Get user context from Farcaster
+const context = await sdk.context;
+const fid = context.user.fid;
+```
+
+**After (wagmi + SIWE):**
+```typescript
+import { useAccount, useSignMessage } from 'wagmi';
+import { createSiweMessage } from 'viem/siwe';
+
+function AuthComponent() {
+  const { address, isConnected } = useAccount();
+  const { signMessageAsync } = useSignMessage();
+  
+  const signIn = async () => {
+    const message = createSiweMessage({
+      address: address!,
+      chainId: 8453, // Base mainnet
+      domain: window.location.host,
+      uri: window.location.origin,
+      version: '1',
+    });
+    
+    const signature = await signMessageAsync({ message });
+    // Verify signature on your backend
+  };
+}
+```
 </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 title="Replace SDK actions">
+Replace Farcaster SDK actions with standard web equivalents:
+
+| Farcaster SDK | Standard Web Equivalent |
+| --- | --- |
+| `sdk.actions.ready()` | Remove (not needed) |
+| `sdk.actions.openUrl()` | `window.open()` |
+| `sdk.actions.viewProfile()` | Link to profile page |
+| `sdk.actions.close()` | `window.close()` |
 </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](/base-chain/builder-codes/builder-codes). Already registered apps do not need to re-register or update metadata.
+<Step title="Update your Base.dev registration">
+Ensure your app is registered on [Base.dev](https://www.base.dev). Update your app metadata if needed:
+- App name and description
+- Icon and screenshots
+- Supported chains
+- Builder code (optional)
 </Step>
 </Steps>
+</Tab>
 
+<Tab title="I'm building a new app">
+If you're building a new app for the Base App, start with standard web patterns:
 
+<Steps>
+<Step title="Set up your project">
+Create a new web app using your preferred framework:
+
+<CodeGroup>
+```bash Next.js
+npx create-next-app@latest my-base-app
+```
+
+```bash Vite
+npm create vite@latest my-base-app -- --template react-ts
+```
+</CodeGroup>
+</Step>
 
-</Tab>
-
-<Tab title="My app has no Farcaster SDK">
+<Step title="Add wallet connection">
+Install wagmi and viem:
 
-Your app is already a standard web app. You're mostly done — just verify your stack and register on Base.dev.
+<CodeGroup>
+```bash npm
+npm install wagmi viem @tanstack/react-query
+```
 
-<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
+```bash pnpm
+pnpm add wagmi viem @tanstack/react-query
+```
+</CodeGroup>
 </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](/base-chain/builder-codes/builder-codes). Already registered apps do not need to re-register or update metadata.
+<Step title="Configure wagmi">
+Set up wagmi with Base chain support:
+
+```typescript config.ts
+import { createConfig, http } from 'wagmi';
+import { base, baseSepolia } from 'wagmi/chains';
+import { injected } from 'wagmi/connectors';
+
+export const config = createConfig({
+  chains: [base, baseSepolia],
+  connectors: [injected()],
+  transports: {
+    [base.id]: http(),
+    [baseSepolia.id]: http(),
+  },
+});
+```
 </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 title="Register on Base.dev">
+Register your app on [Base.dev](https://www.base.dev) to make it discoverable in the Base App.
 </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 mini 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>
+## Testing your migration
 
-<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>
+After migrating, test your app thoroughly:
 
-<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](/base-chain/builder-codes/builder-codes) are all filled in.
-</Step>
+1. **Wallet connection** - Ensure users can connect their wallets
+2. **Sign-in flow** - Test SIWE authentication if implemented
+3. **Base App preview** - Use [Base Build](https://build.base.dev) to preview your app
+4. **Transaction flow** - Verify any on-chain interactions work correctly
 
-<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>
+## Need help?
 
-<Check>
-If all steps above are complete, your app is ready for the Base App as a standard web app.
-</Check>
+- Join the [Base Discord](https://base.org/discord) for community support
+- Check the [Base App documentation](/base-app) for more details
+- Review the [wagmi documentation](https://wagmi.sh) for wallet connection patterns