diff --git a/src/lib/components/efp-stats/efp-stats.svelte b/src/lib/components/efp-stats/efp-stats.svelte
new file mode 100644
index 000000000..6c633f94b
--- /dev/null
+++ b/src/lib/components/efp-stats/efp-stats.svelte
@@ -0,0 +1,92 @@
+<script lang="ts">
+  import Pile from '$lib/components/pile/pile.svelte';
+  import IdentityBadge from '$lib/components/identity-badge/identity-badge.svelte';
+  import formatNumber from '$lib/utils/format-number';
+  import type { EfpCommonFollower, EfpStats } from '$lib/utils/efp';
+  import network from '$lib/stores/wallet/network';
+
+  interface Props {
+    address: string;
+    stats?: EfpStats | null;
+    commonFollowers?: EfpCommonFollower[];
+    showCommonFollowers?: boolean;
+    maxCommonFollowers?: number;
+  }
+
+  let {
+    address,
+    stats = null,
+    commonFollowers = [],
+    showCommonFollowers = false,
+    maxCommonFollowers = 5,
+  }: Props = $props();
+
+  const profileUrl = $derived(`https://efp.app/${encodeURIComponent(address)}`);
+
+  const hasStats = $derived(
+    !!stats && (stats.followers > 0 || stats.following > 0),
+  );
+
+  const visibleCommonFollowers = $derived(
+    showCommonFollowers ? commonFollowers.slice(0, maxCommonFollowers) : [],
+  );
+
+  const showCommon = $derived(visibleCommonFollowers.length > 0);
+
+  const pileComponents = $derived(
+    visibleCommonFollowers.map((follower) => ({
+      component: IdentityBadge,
+      props: {
+        address: follower.address,
+        disableLink: false,
+        disableTooltip: true,
+        size: 'small' as const,
+      },
+    })),
+  );
+</script>
+
+{#if network.enableEfp && (hasStats || showCommon)}
+  <div class="efp-stats typo-text-small">
+    {#if hasStats && stats}
+      <a class="counts" href={profileUrl} target="_blank" rel="noopener noreferrer">
+        {formatNumber(stats.followers)} {stats.followers === 1 ? 'follower' : 'followers'} · {formatNumber(stats.following)} following
+      </a>
+    {/if}
+    {#if showCommon}
+      <div class="common-followers">
+        <span class="label typo-all-caps">Followers you know</span>
+        <Pile components={pileComponents} maxItems={maxCommonFollowers} countOverride={commonFollowers.length} />
+      </div>
+    {/if}
+  </div>
+{/if}
+
+<style>
+  .efp-stats {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+    color: var(--color-foreground-level-5);
+  }
+
+  .counts {
+    color: var(--color-foreground-level-5);
+    text-decoration: none;
+  }
+
+  .counts:hover {
+    color: var(--color-primary);
+    text-decoration: underline;
+  }
+
+  .common-followers {
+    display: flex;
+    flex-direction: column;
+    gap: 0.375rem;
+  }
+
+  .label {
+    color: var(--color-foreground-level-4);
+  }
+</style>
diff --git a/src/lib/components/efp-stats/efp-stats.unit.test.ts b/src/lib/components/efp-stats/efp-stats.unit.test.ts
new file mode 100644
index 000000000..a94ecc7f7
--- /dev/null
+++ b/src/lib/components/efp-stats/efp-stats.unit.test.ts
@@ -0,0 +1,62 @@
+import { render, screen } from '@testing-library/svelte';
+import EfpStats from './efp-stats.svelte';
+
+vi.mock('$lib/stores/wallet/network', () => ({
+  default: { enableEfp: true },
+}));
+
+vi.mock('$lib/components/identity-badge/identity-badge.svelte', async () => ({
+  default: (await import('./identity-badge-stub.svelte')).default,
+}));
+
+vi.mock('$lib/components/pile/pile.svelte', async () => ({
+  default: (await import('./pile-stub.svelte')).default,
+}));
+
+describe('efp-stats.svelte', () => {
+  it('renders follower and following counts when stats are present', () => {
+    render(EfpStats, {
+      props: {
+        address: '0x1234567890123456789012345678901234567890',
+        stats: { followers: 1200, following: 42 },
+      },
+    });
+
+    expect(screen.getByText(/1,200 followers/)).toBeInTheDocument();
+    expect(screen.getByText(/42 following/)).toBeInTheDocument();
+    expect(screen.getByRole('link')).toHaveAttribute(
+      'href',
+      'https://efp.app/0x1234567890123456789012345678901234567890',
+    );
+  });
+
+  it('renders nothing when stats are absent', () => {
+    const { container } = render(EfpStats, {
+      props: {
+        address: '0x1234567890123456789012345678901234567890',
+        stats: null,
+      },
+    });
+
+    expect(container.querySelector('.efp-stats')).toBeNull();
+  });
+
+  it('truncates common followers to maxCommonFollowers', () => {
+    render(EfpStats, {
+      props: {
+        address: '0x1234567890123456789012345678901234567890',
+        stats: { followers: 3, following: 1 },
+        showCommonFollowers: true,
+        maxCommonFollowers: 2,
+        commonFollowers: [
+          { address: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
+          { address: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' },
+          { address: '0xcccccccccccccccccccccccccccccccccccccccc' },
+        ],
+      },
+    });
+
+    expect(screen.getByText('Followers you know')).toBeInTheDocument();
+    expect(screen.getByText('+1')).toBeInTheDocument();
+  });
+});
diff --git a/src/lib/components/efp-stats/identity-badge-stub.svelte b/src/lib/components/efp-stats/identity-badge-stub.svelte
new file mode 100644
index 000000000..11fa49a59
--- /dev/null
+++ b/src/lib/components/efp-stats/identity-badge-stub.svelte
@@ -0,0 +1,9 @@
+<script lang="ts">
+  interface Props {
+    address?: string;
+  }
+
+  let { address }: Props = $props();
+</script>
+
+<span data-testid="identity-badge-stub">{address}</span>
diff --git a/src/lib/components/efp-stats/pile-stub.svelte b/src/lib/components/efp-stats/pile-stub.svelte
new file mode 100644
index 000000000..c60c480e4
--- /dev/null
+++ b/src/lib/components/efp-stats/pile-stub.svelte
@@ -0,0 +1,13 @@
+<script lang="ts">
+  interface Props {
+    maxItems?: number;
+    components?: unknown[];
+    countOverride?: number;
+  }
+
+  let { maxItems = 4, components = [], countOverride }: Props = $props();
+
+  const overflowAmount = $derived((countOverride ?? components.length) - maxItems);
+</script>
+
+{#if overflowAmount > 0}<span>+{overflowAmount}</span>{/if}
diff --git a/src/lib/components/identity-card/identity-card.svelte b/src/lib/components/identity-card/identity-card.svelte
index 6bd8ef7a9..e7721576c 100644
--- a/src/lib/components/identity-card/identity-card.svelte
+++ b/src/lib/components/identity-card/identity-card.svelte
@@ -68,6 +68,9 @@
   import EcosystemIcon from '$lib/components/icons/Ecosystem.svelte';
   import buildOrcidUrl from '$lib/utils/orcids/build-orcid-url';
   import OrcidIcon from '$lib/components/icons/Orcid.svelte';
+  import EfpStats from '$lib/components/efp-stats/efp-stats.svelte';
+  import efpStore from '$lib/stores/efp';
+  import network from '$lib/stores/wallet/network';
 
   // Either pass address, dripList, ecosystem, or project. Otherwise it will say "TBD" as a placeholder.
   export let address: string | undefined = undefined;
@@ -82,6 +85,7 @@
   let avatarImgElem: HTMLImageElement | undefined;
 
   let link: string | undefined;
+
   $: {
     switch (true) {
       case disableLink:
@@ -100,6 +104,12 @@
         link = buildOrcidUrl(orcid.orcid);
     }
   }
+
+  $: if (address && network.enableEfp) {
+    void efpStore.lookupStats(address);
+  }
+
+  $: efpStats = address ? $efpStore[address.toLowerCase()]?.stats : undefined;
 </script>
 
 <svelte:element
@@ -119,6 +129,7 @@
         disableTooltip
       />
       <IdentityBadge disableLink={true} size="huge" {address} showAvatar={false} disableTooltip />
+      <EfpStats {address} stats={efpStats} />
     </div>
   {:else if dripList}
     <div class="content-container" in:fade>
diff --git a/src/lib/components/supporters-section/supporters.section.svelte b/src/lib/components/supporters-section/supporters.section.svelte
index 4bd305bc9..b93e4c92e 100644
--- a/src/lib/components/supporters-section/supporters.section.svelte
+++ b/src/lib/components/supporters-section/supporters.section.svelte
@@ -122,6 +122,9 @@
   import Section from '../section/section.svelte';
   import EcosystemBadge from '../ecosystem-badge/ecosystem-badge.svelte';
   import unreachable from '$lib/utils/unreachable';
+  import network from '$lib/stores/wallet/network';
+  import extractSupporterAddresses from '$lib/utils/efp/extract-supporter-addresses';
+  import { getSupportersYouFollow } from '$lib/utils/efp';
 
   let emptyStateText: string | undefined = $state();
 
@@ -138,6 +141,43 @@
     sectionSkeleton?: SectionSkeleton | undefined;
   }
 
+  let followedSupporters = $state(new Set<string>());
+  let highlightSupportersYouFollow = $state(false);
+  let loadingFollowedSupporters = $state(false);
+
+  function supporterTag(
+    address: string,
+    existingTag: string | undefined,
+  ): string | undefined {
+    if (existingTag) return existingTag;
+    if (
+      highlightSupportersYouFollow &&
+      followedSupporters.has(address.toLowerCase())
+    ) {
+      return 'Following';
+    }
+    return undefined;
+  }
+
+  async function toggleSupportersYouFollow() {
+    if (highlightSupportersYouFollow) {
+      highlightSupportersYouFollow = false;
+      followedSupporters = new Set();
+      return;
+    }
+
+    const viewer = $walletStore.address;
+    if (!viewer || supporterAddresses.length === 0) return;
+
+    loadingFollowedSupporters = true;
+    try {
+      followedSupporters = await getSupportersYouFollow(viewer, supporterAddresses);
+      highlightSupportersYouFollow = true;
+    } finally {
+      loadingFollowedSupporters = false;
+    }
+  }
+
   let {
     supportItems,
     ownerAccountId = undefined,
@@ -149,6 +189,9 @@
     infoTooltip = undefined,
     sectionSkeleton = $bindable(),
   }: Props = $props();
+
+  const supporterAddresses = $derived(extractSupporterAddresses(supportItems));
+
   run(() => {
     switch (type) {
       case 'project':
@@ -185,6 +228,25 @@
     }}
     bind:skeletonInstance={sectionSkeleton}
   >
+    {#if network.enableEfp && type === 'address' && $walletStore.address && supporterAddresses.length > 0}
+      <div class="supporters-you-follow">
+        <button
+          type="button"
+          class="typo-text-small"
+          disabled={loadingFollowedSupporters}
+          aria-pressed={highlightSupportersYouFollow}
+          onclick={toggleSupportersYouFollow}
+        >
+          {#if loadingFollowedSupporters}
+            Loading…
+          {:else if highlightSupportersYouFollow}
+            Hide supporters you follow
+          {:else}
+            Show supporters you follow
+          {/if}
+        </button>
+      </div>
+    {/if}
     <div class="items">
       {#each supportItems as item}
         {#if item.__typename === 'OneTimeDonationSupport'}
@@ -192,12 +254,14 @@
             title={{
               component: IdentityBadge,
               props: {
-                tag:
+                tag: supporterTag(
+                  item.account.address,
                   item.account.accountId === $walletStore.dripsAccountId
                     ? 'You'
                     : item.account.accountId === ownerAccountId
                       ? 'Owner'
                       : undefined,
+                ),
                 disableTooltip: true,
                 address: item.account.address,
               },
@@ -246,12 +310,14 @@
               props: {
                 disableLink: true,
                 disableTooltip: true,
-                tag:
+                tag: supporterTag(
+                  item.stream.sender.account.address,
                   stream.sender.account.accountId === $walletStore.dripsAccountId
                     ? 'You'
                     : stream.sender.account.accountId === ownerAccountId
                       ? 'Owner'
                       : undefined,
+                ),
                 address: item.stream.sender.account.address,
               },
             }}
@@ -356,6 +422,23 @@
 </section>
 
 <style>
+  .supporters-you-follow {
+    margin-bottom: 0.75rem;
+  }
+
+  .supporters-you-follow button {
+    color: var(--color-primary);
+    background: none;
+    border: none;
+    padding: 0;
+    cursor: pointer;
+  }
+
+  .supporters-you-follow button:disabled {
+    opacity: 0.6;
+    cursor: default;
+  }
+
   .items {
     border: 1px solid var(--color-foreground-level-3);
     border-radius: 1rem 0 1rem 1rem;
diff --git a/src/lib/stores/efp/__mocks__/efp.store.ts b/src/lib/stores/efp/__mocks__/efp.store.ts
new file mode 100644
index 000000000..6adf43775
--- /dev/null
+++ b/src/lib/stores/efp/__mocks__/efp.store.ts
@@ -0,0 +1,72 @@
+import { writable } from 'svelte/store';
+import type { EfpCommonFollower, EfpStats } from '$lib/utils/efp';
+
+export const TEST_ADDRESS = '0x1234567890123456789012345678901234567890';
+export const TEST_VIEWER = '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd';
+
+const mockStats: EfpStats = {
+  followers: 42,
+  following: 7,
+};
+
+const mockCommonFollowers: EfpCommonFollower[] = [
+  {
+    address: '0x2222222222222222222222222222222222222222',
+    name: 'alice.eth',
+  },
+];
+
+export function commonFollowersKey(target: string, leader: string) {
+  return `${target.toLowerCase()}:${leader.toLowerCase()}`;
+}
+
+export default (() => {
+  const statsState = writable<Record<string, { stats?: EfpStats }>>({});
+  const commonFollowersState = writable<Record<string, EfpCommonFollower[]>>({});
+
+  function hydrateStats(address: string, stats: EfpStats) {
+    statsState.update((s) => ({ ...s, [address.toLowerCase()]: { stats } }));
+  }
+
+  async function lookupStats(address: string) {
+    if (address.toLowerCase() === TEST_ADDRESS) {
+      statsState.set({ [TEST_ADDRESS]: { stats: mockStats } });
+      return mockStats;
+    }
+    return undefined;
+  }
+
+  async function lookupCommonFollowers(viewedAddress: string, leaderAddress: string) {
+    if (
+      viewedAddress.toLowerCase() === TEST_ADDRESS &&
+      leaderAddress.toLowerCase() === TEST_VIEWER
+    ) {
+      const key = commonFollowersKey(viewedAddress, leaderAddress);
+      commonFollowersState.set({ [key]: mockCommonFollowers });
+      return mockCommonFollowers;
+    }
+    return undefined;
+  }
+
+  return {
+    subscribe: statsState.subscribe,
+    subscribeCommonFollowers: commonFollowersState.subscribe,
+    lookupStats,
+    hydrateStats,
+    lookupCommonFollowers,
+    getStats: (address: string) =>
+      address.toLowerCase() === TEST_ADDRESS ? mockStats : undefined,
+    getCommonFollowersFor: (viewed: string, leader: string) => {
+      const key = commonFollowersKey(viewed, leader);
+      let value: EfpCommonFollower[] | undefined;
+      commonFollowersState.subscribe((s) => {
+        value = s[key];
+      })();
+      return value;
+    },
+    clear: () => {
+      statsState.set({});
+      commonFollowersState.set({});
+    },
+  };
+})();
diff --git a/src/lib/stores/efp/__mocks__/index.ts b/src/lib/stores/efp/__mocks__/index.ts
new file mode 100644
index 000000000..069fa0f0e
--- /dev/null
+++ b/src/lib/stores/efp/__mocks__/index.ts
@@ -0,0 +1 @@
+export { default, TEST_ADDRESS, TEST_VIEWER, commonFollowersKey } from './efp.store';
diff --git a/src/lib/stores/efp/efp.store.ts b/src/lib/stores/efp/efp.store.ts
new file mode 100644
index 000000000..1b35ebc05
--- /dev/null
+++ b/src/lib/stores/efp/efp.store.ts
@@ -0,0 +1,119 @@
+import { get, writable } from 'svelte/store';
+import { browser } from '$app/environment';
+import {
+  getCommonFollowers,
+  getEfpStats,
+  type EfpCommonFollower,
+  type EfpStats,
+} from '$lib/utils/efp';
+import network from '../wallet/network';
+
+export type EfpAddressRecord = {
+  stats?: EfpStats;
+};
+
+type StatsState = {
+  [address: string]: EfpAddressRecord | undefined;
+};
+
+type CommonFollowersState = {
+  [key: string]: EfpCommonFollower[] | undefined;
+};
+
+export function commonFollowersKey(target: string, leader: string) {
+  return `${target.toLowerCase()}:${leader.toLowerCase()}`;
+}
+
+export default (() => {
+  const statsState = writable<StatsState>({});
+  const commonFollowersState = writable<CommonFollowersState>({});
+  const inFlightStats = new Set<string>();
+  const inFlightCommon = new Set<string>();
+
+  async function lookupStats(address: string): Promise<EfpStats | undefined> {
+    if (!browser || !network.enableEfp) return undefined;
+
+    const key = address.toLowerCase();
+    const saved = get(statsState)[key];
+    if (saved?.stats) return saved.stats;
+    if (inFlightStats.has(key)) return undefined;
+
+    inFlightStats.add(key);
+    statsState.update((s) => ({ ...s, [key]: {} }));
+
+    try {
+      const stats = await getEfpStats(address);
+      if (stats) {
+        statsState.update((s) => ({ ...s, [key]: { stats } }));
+        return stats;
+      }
+    } finally {
+      inFlightStats.delete(key);
+    }
+
+    return undefined;
+  }
+
+  async function lookupCommonFollowers(
+    targetAddress: string,
+    leaderAddress: string,
+    limit = 5,
+  ): Promise<EfpCommonFollower[] | undefined> {
+    if (!browser || !network.enableEfp) return undefined;
+
+    const key = commonFollowersKey(targetAddress, leaderAddress);
+    const saved = get(commonFollowersState)[key];
+    if (saved) return saved;
+    if (inFlightCommon.has(key)) return undefined;
+
+    inFlightCommon.add(key);
+
+    try {
+      const results = await getCommonFollowers(targetAddress, leaderAddress, fetch, limit);
+      if (results) {
+        commonFollowersState.update((s) => ({ ...s, [key]: results }));
+        return results;
+      }
+    } finally {
+      inFlightCommon.delete(key);
+    }
+
+    return undefined;
+  }
+
+  function hydrateStats(address: string, stats: EfpStats) {
+    if (!browser || !network.enableEfp) return;
+
+    const key = address.toLowerCase();
+    statsState.update((s) => ({ ...s, [key]: { stats } }));
+  }
+
+  function getStats(address: string): EfpStats | undefined {
+    return get(statsState)[address.toLowerCase()]?.stats;
+  }
+
+  function getCommonFollowersFor(
+    targetAddress: string,
+    leaderAddress: string,
+  ): EfpCommonFollower[] | undefined {
+    return get(commonFollowersState)[commonFollowersKey(targetAddress, leaderAddress)];
+  }
+
+  function clear() {
+    statsState.set({});
+    commonFollowersState.set({});
+    inFlightStats.clear();
+    inFlightCommon.clear();
+  }
+
+  return {
+    subscribe: statsState.subscribe,
+    subscribeCommonFollowers: commonFollowersState.subscribe,
+    lookupStats,
+    hydrateStats,
+    lookupCommonFollowers,
+    getStats,
+    getCommonFollowersFor,
+    clear,
+  };
+})();
diff --git a/src/lib/stores/efp/efp.store.unit.test.ts b/src/lib/stores/efp/efp.store.unit.test.ts
new file mode 100644
index 000000000..be40e4552
--- /dev/null
+++ b/src/lib/stores/efp/efp.store.unit.test.ts
@@ -0,0 +1,96 @@
+import { get } from 'svelte/store';
+import efpStore from '.';
+import * as efpApi from '$lib/utils/efp';
+
+vi.mock('$app/environment', () => ({
+  browser: true,
+  dev: true,
+}));
+
+vi.mock('$lib/stores/wallet/network', () => ({
+  default: { enableEfp: true },
+}));
+
+vi.mock('$lib/utils/efp', () => ({
+  getEfpStats: vi.fn(),
+  getCommonFollowers: vi.fn(),
+}));
+
+const getEfpStats = vi.mocked(efpApi.getEfpStats);
+const getCommonFollowers = vi.mocked(efpApi.getCommonFollowers);
+
+afterEach(() => {
+  efpStore.clear();
+  vi.clearAllMocks();
+});
+
+describe('efp store', () => {
+  it('normalizes address keys to lowercase', async () => {
+    getEfpStats.mockResolvedValue({ followers: 10, following: 2 });
+
+    await efpStore.lookupStats('0xAbCdEf0123456789012345678901234567890AbCdEf');
+
+    expect(get(efpStore)['0xabcdef0123456789012345678901234567890abcdef']?.stats).toEqual({
+      followers: 10,
+      following: 2,
+    });
+  });
+
+  it('deduplicates in-flight stats lookups', async () => {
+    getEfpStats.mockResolvedValue({ followers: 1, following: 1 });
+
+    const address = '0x1111111111111111111111111111111111111111';
+    void efpStore.lookupStats(address);
+    void efpStore.lookupStats(address);
+    await efpStore.lookupStats(address);
+
+    expect(getEfpStats).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns undefined without throwing when lookup fails', async () => {
+    getEfpStats.mockResolvedValue(null);
+
+    const result = await efpStore.lookupStats('0x2222222222222222222222222222222222222222');
+
+    expect(result).toBeUndefined();
+    expect(get(efpStore)['0x2222222222222222222222222222222222222222']).toEqual({});
+  });
+
+  it('hydrates stats from SSR without fetching', () => {
+    efpStore.hydrateStats('0x7777777777777777777777777777777777777777', {
+      followers: 99,
+      following: 11,
+    });
+
+    expect(getEfpStats).not.toHaveBeenCalled();
+    expect(get(efpStore)['0x7777777777777777777777777777777777777777']?.stats).toEqual({
+      followers: 99,
+      following: 11,
+    });
+  });
+
+  it('clears cached state', async () => {
+    getEfpStats.mockResolvedValue({ followers: 5, following: 1 });
+    await efpStore.lookupStats('0x3333333333333333333333333333333333333333');
+
+    efpStore.clear();
+
+    expect(get(efpStore)).toEqual({});
+  });
+
+  it('caches common followers by target and leader', async () => {
+    getCommonFollowers.mockResolvedValue([
+      { address: '0x4444444444444444444444444444444444444444' },
+    ]);
+
+    const target = '0x5555555555555555555555555555555555555555';
+    const leader = '0x6666666666666666666666666666666666666666';
+
+    await efpStore.lookupCommonFollowers(target, leader);
+
+    expect(getCommonFollowers).toHaveBeenCalledWith(target, leader, expect.any(Function), 5);
+    expect(efpStore.getCommonFollowersFor(target, leader)).toEqual([
+      { address: '0x4444444444444444444444444444444444444444' },
+    ]);
+  });
+});
diff --git a/src/lib/stores/efp/index.ts b/src/lib/stores/efp/index.ts
new file mode 100644
index 000000000..161ff8d83
--- /dev/null
+++ b/src/lib/stores/efp/index.ts
@@ -0,0 +1 @@
+export { default, commonFollowersKey } from './efp.store';
diff --git a/src/lib/stores/wallet/network.ts b/src/lib/stores/wallet/network.ts
index 0812581b7..1dccc94e7 100644
--- a/src/lib/stores/wallet/network.ts
+++ b/src/lib/stores/wallet/network.ts
@@ -80,6 +80,7 @@ export type Network = {
       }
     | undefined;
   enableEns: boolean;
+  enableEfp: boolean;
   ecosystems: boolean;
   retroFunding: DripsRetroFundingConfig;
   orcids: boolean;
@@ -168,6 +169,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
     gaslessTransactions: false,
     addToWalletConfig: undefined,
     enableEns: true,
+    enableEfp: true,
     ecosystems: false,
     retroFunding: { enabled: false },
     orcids: false,
@@ -214,6 +216,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
     gaslessTransactions: false,
     addToWalletConfig: undefined,
     enableEns: true,
+    enableEfp: true,
     ecosystems: false,
     retroFunding: { enabled: false },
     orcids: false,
@@ -260,6 +263,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
     gaslessTransactions: false,
     addToWalletConfig: undefined,
     enableEns: true,
+    enableEfp: true,
     ecosystems: true,
     retroFunding: { enabled: false },
     orcids: false,
@@ -307,6 +311,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
     gaslessTransactions: false,
     addToWalletConfig: undefined,
     enableEns: true,
+    enableEfp: true,
     ecosystems: true,
     retroFunding: {
       enabled: true,
@@ -373,6 +378,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
       rpcUrls: [`${BASE_URL}/api/rpc/anvil/localtestnet`],
     },
     enableEns: false,
+    enableEfp: false,
     ecosystems: true,
     retroFunding: {
       enabled: true,
@@ -424,6 +430,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
     gaslessTransactions: false,
     addToWalletConfig: undefined,
     enableEns: true,
+    enableEfp: true,
     retroFunding: { enabled: false },
     ecosystems: false,
     orcids: false,
@@ -489,6 +496,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
       ],
     },
     enableEns: true,
+    enableEfp: true,
     retroFunding: {
       enabled: true,
       attestationConfig: {
@@ -554,6 +562,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
       rpcUrls: ['https://andromeda.metis.io/?owner=1088'],
     },
     enableEns: true,
+    enableEfp: true,
     retroFunding: { enabled: false },
     ecosystems: false,
     orcids: false,
@@ -608,6 +617,7 @@ export const NETWORK_CONFIG: ValueForEachSupportedChain<Network> = {
       rpcUrls: ['https://mainnet.optimism.io'],
     },
     enableEns: true,
+    enableEfp: true,
     retroFunding: { enabled: false },
     ecosystems: false,
     orcids: false,
diff --git a/src/lib/utils/efp/extract-supporter-addresses.ts b/src/lib/utils/efp/extract-supporter-addresses.ts
new file mode 100644
index 000000000..8472192e4
--- /dev/null
+++ b/src/lib/utils/efp/extract-supporter-addresses.ts
@@ -0,0 +1,17 @@
+import type { SupportersSectionSupportItemFragment } from '$lib/components/supporters-section/__generated__/gql.generated';
+
+export default function extractSupporterAddresses(
+  supportItems: SupportersSectionSupportItemFragment[],
+): string[] {
+  const addresses = new Set<string>();
+
+  for (const item of supportItems) {
+    if (item.__typename === 'OneTimeDonationSupport') {
+      addresses.add(item.account.address.toLowerCase());
+    } else if (item.__typename === 'StreamSupport') {
+      addresses.add(item.stream.sender.account.address.toLowerCase());
+    }
+  }
+
+  return [...addresses];
+}
diff --git a/src/lib/utils/efp/extract-supporter-addresses.unit.test.ts b/src/lib/utils/efp/extract-supporter-addresses.unit.test.ts
new file mode 100644
index 000000000..c10735e78
--- /dev/null
+++ b/src/lib/utils/efp/extract-supporter-addresses.unit.test.ts
@@ -0,0 +1,36 @@
+import extractSupporterAddresses from './extract-supporter-addresses';
+import type { SupportersSectionSupportItemFragment } from '$lib/components/supporters-section/__generated__/gql.generated';
+
+describe('extractSupporterAddresses', () => {
+  it('collects unique lowercase addresses from donations and streams', () => {
+    const supportItems = [
+      {
+        __typename: 'OneTimeDonationSupport',
+        account: { address: '0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' },
+      },
+      {
+        __typename: 'StreamSupport',
+        stream: {
+          sender: { account: { address: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb' } },
+        },
+      },
+      {
+        __typename: 'OneTimeDonationSupport',
+        account: { address: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
+      },
+    ] as SupportersSectionSupportItemFragment[];
+
+    expect(extractSupporterAddresses(supportItems)).toEqual([
+      '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+    ]);
+  });
+
+  it('ignores unsupported support item types', () => {
+    const supportItems = [
+      { __typename: 'UnsupportedSupport' },
+    ] as SupportersSectionSupportItemFragment[];
+
+    expect(extractSupporterAddresses(supportItems)).toEqual([]);
+  });
+});
diff --git a/src/lib/utils/efp/index.ts b/src/lib/utils/efp/index.ts
new file mode 100644
index 000000000..d5f004003
--- /dev/null
+++ b/src/lib/utils/efp/index.ts
@@ -0,0 +1,147 @@
+export const EFP_API_BASE = 'https://api.ethfollow.xyz/api/v1';
+
+export interface EfpStats {
+  followers: number;
+  following: number;
+}
+
+export interface EfpCommonFollower {
+  address: string;
+  name?: string;
+  avatar?: string;
+  mutualsRank?: number;
+}
+
+export interface EfpFollowerState {
+  follow: boolean;
+  block: boolean;
+  mute: boolean;
+}
+
+function parseCount(value: string | number | undefined): number {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : 0;
+}
+
+function parseOptionalCount(value: string | number | undefined): number | undefined {
+  if (value === undefined || value === null || value === '') return undefined;
+  const n = Number(value);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function encodeUserId(id: string): string {
+  return encodeURIComponent(id);
+}
+
+export async function getEfpStats(
+  addressOrEns: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<EfpStats | null> {
+  try {
+    const response = await fetchFn(`${EFP_API_BASE}/users/${encodeUserId(addressOrEns)}/stats`);
+    if (!response.ok) return null;
+
+    const data = (await response.json()) as {
+      followers_count?: string | number;
+      following_count?: string | number;
+    };
+
+    const followers = parseCount(data.followers_count);
+    const following = parseCount(data.following_count);
+
+    return { followers, following };
+  } catch {
+    return null;
+  }
+}
+
+export async function getCommonFollowers(
+  addressOrEns: string,
+  leader: string,
+  fetchFn: typeof fetch = fetch,
+  limit = 5,
+): Promise<EfpCommonFollower[] | null> {
+  try {
+    const url = new URL(
+      `${EFP_API_BASE}/users/${encodeUserId(addressOrEns)}/commonFollowers`,
+    );
+    url.searchParams.set('leader', leader);
+
+    const response = await fetchFn(url.toString());
+    if (!response.ok) return null;
+
+    const data = (await response.json()) as {
+      results?: Array<{
+        address: string;
+        name?: string;
+        avatar?: string;
+        mutuals_rank?: string;
+      }>;
+    };
+
+    if (!data.results?.length) return [];
+
+    return data.results.slice(0, limit).map((row) => ({
+      address: row.address,
+      name: row.name,
+      avatar: row.avatar,
+      mutualsRank: parseOptionalCount(row.mutuals_rank),
+    }));
+  } catch {
+    return null;
+  }
+}
+
+export async function getFollowerState(
+  userAddressOrEns: string,
+  followerAddressOrEns: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<EfpFollowerState | null> {
+  try {
+    const response = await fetchFn(
+      `${EFP_API_BASE}/users/${encodeUserId(userAddressOrEns)}/${encodeUserId(followerAddressOrEns)}/followerState`,
+    );
+    if (!response.ok) return null;
+
+    const data = (await response.json()) as {
+      state?: { follow?: boolean; block?: boolean; mute?: boolean };
+    };
+
+    if (!data.state) return null;
+
+    return {
+      follow: !!data.state.follow,
+      block: !!data.state.block,
+      mute: !!data.state.mute,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function getSupportersYouFollow(
+  viewerAddress: string,
+  supporterAddresses: string[],
+  fetchFn: typeof fetch = fetch,
+  concurrency = 5,
+): Promise<Set<string>> {
+  const followed = new Set<string>();
+  const unique = [...new Set(supporterAddresses.map((a) => a.toLowerCase()))].filter(
+    (a) => a !== viewerAddress.toLowerCase(),
+  );
+
+  for (let i = 0; i < unique.length; i += concurrency) {
+    const batch = unique.slice(i, i + concurrency);
+    const results = await Promise.all(
+      batch.map(async (supporter) => {
+        const state = await getFollowerState(supporter, viewerAddress, fetchFn);
+        return state?.follow ? supporter : null;
+      }),
+    );
+    for (const address of results) {
+      if (address) followed.add(address);
+    }
+  }
+
+  return followed;
+}
diff --git a/src/lib/utils/efp/index.unit.test.ts b/src/lib/utils/efp/index.unit.test.ts
new file mode 100644
index 000000000..ae57a56b6
--- /dev/null
+++ b/src/lib/utils/efp/index.unit.test.ts
@@ -0,0 +1,91 @@
+import { describe, expect, it, vi } from 'vitest';
+import { getEfpStats, getFollowerState, getCommonFollowers, getSupportersYouFollow } from './index';
+
+describe('efp api client', () => {
+  it('parses stats counts from string fields', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ followers_count: '104', following_count: '26' }),
+    });
+
+    const stats = await getEfpStats('0xabc', fetchFn);
+
+    expect(stats).toEqual({ followers: 104, following: 26 });
+  });
+
+  it('returns null when stats request fails', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({ ok: false });
+
+    expect(await getEfpStats('0xabc', fetchFn)).toBeNull();
+  });
+
+  it('parses follower state', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        state: { follow: true, block: false, mute: false },
+      }),
+    });
+
+    const state = await getFollowerState('0xuser', '0xfollower', fetchFn);
+
+    expect(state).toEqual({ follow: true, block: false, mute: false });
+  });
+
+  it('parses common followers', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        results: [
+          {
+            address: '0x1',
+            name: 'alice.eth',
+            mutuals_rank: '3',
+          },
+        ],
+      }),
+    });
+
+    const results = await getCommonFollowers('0xtarget', '0xleader', fetchFn);
+
+    expect(results).toEqual([
+      { address: '0x1', name: 'alice.eth', avatar: undefined, mutualsRank: 3 },
+    ]);
+  });
+
+  it('omits mutualsRank when the API returns a non-numeric value', async () => {
+    const fetchFn = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        results: [{ address: '0x1', mutuals_rank: 'n/a' }],
+      }),
+    });
+
+    const results = await getCommonFollowers('0xtarget', '0xleader', fetchFn);
+
+    expect(results).toEqual([{ address: '0x1', name: undefined, avatar: undefined }]);
+  });
+
+  it('returns supporters the viewer follows', async () => {
+    const fetchFn = vi.fn(async (url: string) => {
+      const normalizedUrl = url.toLowerCase();
+      const follows =
+        normalizedUrl.includes('0xsupporter1') && normalizedUrl.includes('0xviewer');
+      return {
+        ok: true,
+        json: async () => ({
+          state: { follow: follows, block: false, mute: false },
+        }),
+      };
+    });
+
+    const followed = await getSupportersYouFollow(
+      '0xViewer',
+      ['0xSupporter1', '0xSupporter2', '0xviewer'],
+      fetchFn,
+    );
+
+    expect(followed).toEqual(new Set(['0xsupporter1']));
+    expect(fetchFn).toHaveBeenCalledTimes(2);
+  });
+});
diff --git a/src/routes/(pages)/app/(app)/[accountId]/+page.server.ts b/src/routes/(pages)/app/(app)/[accountId]/+page.server.ts
index d742abb9f..848cce562 100644
--- a/src/routes/(pages)/app/(app)/[accountId]/+page.server.ts
+++ b/src/routes/(pages)/app/(app)/[accountId]/+page.server.ts
@@ -16,6 +16,7 @@ import { extractDriverNameFromAccountId } from '$lib/utils/sdk/utils/extract-dri
 import { getMainnetProvider, safeReverseLookup } from '$lib/stores/ens/ens';
 import { JsonRpcProvider } from 'ethers';
 import { LINKED_IDENTITIES_CARD_FRAGMENT } from './components/linked-identities-card.svelte';
+import { getEfpStats } from '$lib/utils/efp';
 
 const currentNetworkProvider = new JsonRpcProvider(network.rpcUrl);
 
@@ -137,7 +138,7 @@ export const load = async ({ params, fetch }) => {
     error(404, 'Not Found');
   }
 
-  const [votingRounds, userRes, ensData] = await Promise.all([
+  const [votingRounds, userRes, ensData, efp] = await Promise.all([
     await getVotingRounds({ publisherAddress: address }, fetch),
     query<ProfilePageQuery, ProfilePageQueryVariables>(
       PROFILE_PAGE_QUERY,
@@ -145,6 +146,7 @@ export const load = async ({ params, fetch }) => {
       fetch,
     ),
     resolveEnsFields(address),
+    network.enableEfp ? getEfpStats(address, fetch) : Promise.resolve(null),
   ]);
 
   const votingRoundsWithResults = votingRounds.filter((v) => v.result);
@@ -162,6 +164,7 @@ export const load = async ({ params, fetch }) => {
     blockWhileInitializing: false,
     error: false,
     ensData,
+    efp,
     profileData: {
       ...userRes.userByAddress,
       votingRounds: votingRoundsWithSplits,
diff --git a/src/routes/(pages)/app/(app)/[accountId]/+page.svelte b/src/routes/(pages)/app/(app)/[accountId]/+page.svelte
index 29068dce8..5365064d9 100644
--- a/src/routes/(pages)/app/(app)/[accountId]/+page.svelte
+++ b/src/routes/(pages)/app/(app)/[accountId]/+page.svelte
@@ -18,9 +18,52 @@
   import SupportCard from '$lib/components/support-card/support-card.svelte';
   import LinkedIdentitiesCard from './components/linked-identities-card.svelte';
   import network from '$lib/stores/wallet/network';
+  import { onDestroy } from 'svelte';
+  import EfpStats from '$lib/components/efp-stats/efp-stats.svelte';
+  import efpStore, { commonFollowersKey } from '$lib/stores/efp';
+  import type { EfpCommonFollower } from '$lib/utils/efp';
 
   export let data;
 
+  let commonFollowersCache: Record<string, EfpCommonFollower[] | undefined> = {};
+  const unsubscribeCommonFollowers = efpStore.subscribeCommonFollowers((state) => {
+    commonFollowersCache = state;
+  });
+  onDestroy(unsubscribeCommonFollowers);
+
+  $: profileAddress = data.profileData?.account.address;
+
+  $: if (profileAddress && data.efp) {
+    efpStore.hydrateStats(profileAddress, data.efp);
+  }
+
+  $: profileEfpStats = profileAddress
+    ? ($efpStore[profileAddress.toLowerCase()]?.stats ?? data.efp)
+    : data.efp;
+
+  $: commonFollowersLookupParams =
+    network.enableEfp && profileAddress && $walletStore.address
+      ? { profile: profileAddress, viewer: $walletStore.address }
+      : null;
+
+  $: commonFollowers = (() => {
+    if (!commonFollowersLookupParams) return [];
+    const { profile, viewer } = commonFollowersLookupParams;
+    if (viewer.toLowerCase() === profile.toLowerCase()) return [];
+    return commonFollowersCache[commonFollowersKey(profile, viewer)] ?? [];
+  })();
+
+  function refreshCommonFollowers(params: { profile: string; viewer: string } | null) {
+    if (!params) return;
+
+    const { profile, viewer } = params;
+    if (viewer.toLowerCase() === profile.toLowerCase()) return;
+
+    void efpStore.lookupCommonFollowers(profile, viewer);
+  }
+
+  $: refreshCommonFollowers(commonFollowersLookupParams);
+
   $: socialLinkValues = {
     'com.twitter': data.ensData?.records['com.twitter'],
     'com.github': data.ensData?.records['com.github'],
@@ -78,13 +121,23 @@
                 <div in:fade>
                   <SocialLink network="ethereum" value={data.profileData.account.address} />
                 </div>
-                {#each Object.entries(socialLinkValues ?? {}) as [network, value]}
+                {#each Object.entries(socialLinkValues ?? {}) as [network, value] (network)}
                   {#if value}<li in:fade>
                       <SocialLink network={isNetwork(network) ? network : unreachable()} {value} />
                     </li>{/if}
                 {/each}
               </ul>
               {#if description}<p in:fade>{description}</p>{/if}
+              {#if network.enableEfp}
+                <div in:fade>
+                  <EfpStats
+                    address={data.profileData.account.address}
+                    stats={profileEfpStats}
+                    {commonFollowers}
+                    showCommonFollowers={commonFollowers.length > 0}
+                  />
+                </div>
+              {/if}
             </div>
           </div>
         </header>