diff --git a/keyserver/src/creators/farcaster-channel-tag-creator.js b/keyserver/src/creators/farcaster-channel-tag-creator.js
index 109276b91..3c9f75e73 100644
--- a/keyserver/src/creators/farcaster-channel-tag-creator.js
+++ b/keyserver/src/creators/farcaster-channel-tag-creator.js
@@ -1,89 +1,94 @@
 // @flow
 
 import uuid from 'uuid';
 
+import { DISABLE_TAGGING_FARCASTER_CHANNEL } from 'lib/shared/community-utils.js';
 import type {
   CreateOrUpdateFarcasterChannelTagRequest,
   CreateOrUpdateFarcasterChannelTagResponse,
 } from 'lib/types/community-types.js';
 import { ServerError } from 'lib/utils/errors.js';
 
 import {
   uploadBlob,
   assignHolder,
   download,
   type BlobOperationResult,
   type BlobDownloadResult,
 } from '../services/blob.js';
 import { Viewer } from '../session/viewer.js';
 
 async function createOrUpdateFarcasterChannelTag(
   viewer: Viewer,
   request: CreateOrUpdateFarcasterChannelTagRequest,
 ): Promise<CreateOrUpdateFarcasterChannelTagResponse> {
   const { commCommunityID, farcasterChannelID } = request;
 
+  if (DISABLE_TAGGING_FARCASTER_CHANNEL) {
+    throw new ServerError('internal_error');
+  }
+
   const blobDownload = await getFarcasterChannelTagBlob(farcasterChannelID);
 
   if (blobDownload.found) {
     throw new ServerError('already_in_use');
   }
 
   const blobHolder = uuid.v4();
 
   const blobResult = await uploadFarcasterChannelTagBlob(
     commCommunityID,
     farcasterChannelID,
     blobHolder,
   );
 
   if (!blobResult.success) {
     if (blobResult.reason === 'HASH_IN_USE') {
       throw new ServerError('already_in_use');
     } else {
       throw new ServerError('unknown_error');
     }
   }
 
   return {
     commCommunityID,
     blobHolder,
   };
 }
 
 function farcasterChannelTagBlobHash(secret: string): string {
   return `farcaster_channel_tag_${secret}`;
 }
 
 function getFarcasterChannelTagBlob(
   secret: string,
 ): Promise<BlobDownloadResult> {
   const hash = farcasterChannelTagBlobHash(secret);
 
   return download(hash);
 }
 
 async function uploadFarcasterChannelTagBlob(
   commCommunityID: string,
   farcasterChannelID: string,
   holder: string,
 ): Promise<BlobOperationResult> {
   const payload = {
     commCommunityID,
     farcasterChannelID,
   };
   const payloadString = JSON.stringify(payload);
 
   const hash = farcasterChannelTagBlobHash(farcasterChannelID);
   const blob = new Blob([payloadString]);
 
   const uploadResult = await uploadBlob(blob, hash);
 
   if (!uploadResult.success) {
     return uploadResult;
   }
 
   return await assignHolder({ holder, hash });
 }
 
 export { createOrUpdateFarcasterChannelTag, uploadFarcasterChannelTagBlob };
diff --git a/lib/shared/community-utils.js b/lib/shared/community-utils.js
new file mode 100644
index 000000000..3c25673f1
--- /dev/null
+++ b/lib/shared/community-utils.js
@@ -0,0 +1,5 @@
+// @flow
+
+const DISABLE_TAGGING_FARCASTER_CHANNEL = true;
+
+export { DISABLE_TAGGING_FARCASTER_CHANNEL };
diff --git a/native/components/community-actions-button.react.js b/native/components/community-actions-button.react.js
index ed20b98b0..e3597902e 100644
--- a/native/components/community-actions-button.react.js
+++ b/native/components/community-actions-button.react.js
@@ -1,192 +1,194 @@
 // @flow
 
 import { useActionSheet } from '@expo/react-native-action-sheet';
 import { useNavigation } from '@react-navigation/native';
 import * as React from 'react';
 import { TouchableOpacity, View } from 'react-native';
 import { useSafeAreaInsets } from 'react-native-safe-area-context';
 
 import { primaryInviteLinksSelector } from 'lib/selectors/invite-links-selectors.js';
+import { DISABLE_TAGGING_FARCASTER_CHANNEL } from 'lib/shared/community-utils.js';
 import { useThreadHasPermission } from 'lib/shared/thread-utils.js';
 import type { ThreadInfo } from 'lib/types/minimally-encoded-thread-permissions-types.js';
 import { threadPermissions } from 'lib/types/thread-permission-types.js';
 import { threadTypes } from 'lib/types/thread-types-enum.js';
 import { useCurrentUserFID } from 'lib/utils/farcaster-utils.js';
 import { usingCommServicesAccessToken } from 'lib/utils/services-utils.js';
 
 import SWMansionIcon from './swmansion-icon.react.js';
 import {
   CommunityRolesScreenRouteName,
   InviteLinkNavigatorRouteName,
   ManagePublicLinkRouteName,
   RolesNavigatorRouteName,
   ViewInviteLinksRouteName,
   TagFarcasterChannelNavigatorRouteName,
   TagFarcasterChannelRouteName,
 } from '../navigation/route-names.js';
 import { useSelector } from '../redux/redux-utils.js';
 import { useStyles } from '../themes/colors.js';
 
 type Props = {
   +community: ThreadInfo,
 };
 
 function CommunityActionsButton(props: Props): React.Node {
   const { community } = props;
   const inviteLink = useSelector(primaryInviteLinksSelector)[community.id];
 
   const { navigate } = useNavigation();
 
   const fid = useCurrentUserFID();
 
   const navigateToInviteLinksView = React.useCallback(() => {
     if (!inviteLink || !community) {
       return;
     }
     navigate<'InviteLinkNavigator'>(InviteLinkNavigatorRouteName, {
       screen: ViewInviteLinksRouteName,
       params: {
         community,
       },
     });
   }, [community, inviteLink, navigate]);
 
   const navigateToManagePublicLinkView = React.useCallback(() => {
     navigate<'InviteLinkNavigator'>(InviteLinkNavigatorRouteName, {
       screen: ManagePublicLinkRouteName,
       params: {
         community,
       },
     });
   }, [community, navigate]);
 
   const navigateToCommunityRolesScreen = React.useCallback(() => {
     navigate<'RolesNavigator'>(RolesNavigatorRouteName, {
       screen: CommunityRolesScreenRouteName,
       params: {
         threadInfo: community,
       },
     });
   }, [community, navigate]);
 
   const navigateToTagFarcasterChannel = React.useCallback(() => {
     navigate<'TagFarcasterChannelNavigator'>(
       TagFarcasterChannelNavigatorRouteName,
       {
         screen: TagFarcasterChannelRouteName,
       },
     );
   }, [navigate]);
 
   const insets = useSafeAreaInsets();
   const activeTheme = useSelector(state => state.globalThemeInfo.activeTheme);
   const styles = useStyles(unboundStyles);
 
   const canManageLinks = useThreadHasPermission(
     community,
     threadPermissions.MANAGE_INVITE_LINKS,
   );
   const canChangeRoles = useThreadHasPermission(
     community,
     threadPermissions.CHANGE_ROLE,
   );
 
   const { showActionSheetWithOptions } = useActionSheet();
   const actions = React.useMemo(() => {
     if (!community) {
       return null;
     }
 
     const result = [];
     if (canManageLinks) {
       result.push({
         label: 'Manage invite links',
         action: navigateToManagePublicLinkView,
       });
     }
 
     if (inviteLink) {
       result.push({
         label: 'Invite link',
         action: navigateToInviteLinksView,
       });
     }
 
     if (canChangeRoles) {
       result.push({
         label: 'Manage roles',
         action: navigateToCommunityRolesScreen,
       });
     }
 
     const canTagFarcasterChannel =
+      !DISABLE_TAGGING_FARCASTER_CHANNEL &&
       fid &&
       community.type !== threadTypes.GENESIS &&
       (usingCommServicesAccessToken || __DEV__);
 
     if (canTagFarcasterChannel) {
       result.push({
         label: 'Tag Farcaster channel',
         action: navigateToTagFarcasterChannel,
       });
     }
 
     if (result.length > 0) {
       return result;
     }
     return null;
   }, [
     community,
     canManageLinks,
     inviteLink,
     canChangeRoles,
     fid,
     navigateToManagePublicLinkView,
     navigateToInviteLinksView,
     navigateToCommunityRolesScreen,
     navigateToTagFarcasterChannel,
   ]);
 
   const openActionSheet = React.useCallback(() => {
     if (!actions) {
       return;
     }
     const options = [...actions.map(a => a.label), 'Cancel'];
     showActionSheetWithOptions(
       {
         options,
         cancelButtonIndex: options.length - 1,
         containerStyle: {
           paddingBottom: insets.bottom,
         },
         userInterfaceStyle: activeTheme ?? 'dark',
       },
       selectedIndex => {
         if (selectedIndex !== undefined && selectedIndex < actions.length) {
           actions[selectedIndex].action();
         }
       },
     );
   }, [actions, activeTheme, insets.bottom, showActionSheetWithOptions]);
 
   let button = null;
   if (actions) {
     button = (
       <TouchableOpacity onPress={openActionSheet}>
         <SWMansionIcon name="menu-vertical" size={22} style={styles.button} />
       </TouchableOpacity>
     );
   }
   return <View style={styles.container}>{button}</View>;
 }
 
 const unboundStyles = {
   button: {
     color: 'drawerItemLabelLevel0',
   },
   container: {
     width: 22,
   },
 };
 
 export default CommunityActionsButton;