diff --git a/static/app/views/projectInstall/createProject.spec.tsx b/static/app/views/projectInstall/createProject.spec.tsx
index 59514e23d5bd96..2ddbb7e9ed8540 100644
--- a/static/app/views/projectInstall/createProject.spec.tsx
+++ b/static/app/views/projectInstall/createProject.spec.tsx
@@ -10,12 +10,14 @@ import {
   userEvent,
   waitFor,
 } from 'sentry-test/reactTestingLibrary';
+import selectEvent from 'sentry-test/selectEvent';
 
 import {addErrorMessage, addSuccessMessage} from 'sentry/actionCreators/indicator';
 import OrganizationStore from 'sentry/stores/organizationStore';
 import TeamStore from 'sentry/stores/teamStore';
 import type {Organization} from 'sentry/types/organization';
 import {CreateProject} from 'sentry/views/projectInstall/createProject';
+import * as useValidateChannelModule from 'sentry/views/projectInstall/useValidateChannel';
 
 jest.mock('sentry/actionCreators/indicator');
 
@@ -77,17 +79,24 @@ describe('CreateProject', () => {
     access: ['team:admin', 'team:write', 'team:read'],
   });
 
+  const integration = OrganizationIntegrationsFixture({
+    name: "Moo Deng's Workspace",
+  });
+
   beforeEach(() => {
     TeamStore.reset();
     TeamStore.loadUserTeams([teamNoAccess]);
 
     MockApiClient.addMockResponse({
       url: `/organizations/org-slug/integrations/?integrationType=messaging`,
-      body: [
-        OrganizationIntegrationsFixture({
-          name: "Moo Deng's Workspace",
-        }),
-      ],
+      body: [integration],
+    });
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/org-slug/integrations/${integration.id}/channels/`,
+      body: {
+        results: [],
+      },
     });
   });
 
@@ -428,6 +437,102 @@ describe('CreateProject', () => {
       expect(projectCreationMockRequest).toHaveBeenCalled();
     });
 
+    it('should disable submit button when channel validation fails and integration is selected', async () => {
+      renderFrameworkModalMockRequests({
+        organization,
+        teamSlug: teamWithAccess.slug,
+      });
+
+      MockApiClient.addMockResponse({
+        url: `/organizations/${organization.slug}/integrations/${integration.id}/channel-validate/`,
+        body: {valid: false, detail: 'Channel not found'},
+      });
+
+      render(<CreateProject />, {organization});
+
+      await userEvent.click(screen.getByTestId('platform-apple-ios'));
+      expect(screen.getByRole('button', {name: 'Create Project'})).toBeEnabled();
+      await userEvent.click(
+        screen.getByRole('checkbox', {
+          name: /Notify via integration/,
+        })
+      );
+      await selectEvent.create(screen.getByLabelText('channel'), '#custom-channel', {
+        waitForElement: false,
+        createOptionText: '#custom-channel',
+      });
+      expect(await screen.findByText('Channel not found')).toBeInTheDocument();
+      expect(screen.getByRole('button', {name: 'Create Project'})).toBeDisabled();
+      await userEvent.hover(screen.getByRole('button', {name: 'Create Project'}));
+      expect(await screen.findByText('Channel not found')).toBeInTheDocument();
+      await userEvent.click(screen.getByLabelText('Clear choices'));
+      await userEvent.hover(screen.getByRole('button', {name: 'Create Project'}));
+      expect(
+        await screen.findByText(/provide an integration channel/)
+      ).toBeInTheDocument();
+    });
+
+    it('should NOT disable submit button when channel validation fails but integration is unchecked', async () => {
+      renderFrameworkModalMockRequests({
+        organization,
+        teamSlug: teamWithAccess.slug,
+      });
+
+      MockApiClient.addMockResponse({
+        url: `/organizations/${organization.slug}/integrations/${integration.id}/channel-validate/`,
+        body: {valid: false, detail: 'Channel not found'},
+      });
+
+      render(<CreateProject />, {organization});
+
+      await userEvent.click(screen.getByTestId('platform-apple-ios'));
+      await userEvent.click(
+        screen.getByRole('checkbox', {
+          name: /Notify via integration/,
+        })
+      );
+      await selectEvent.create(screen.getByLabelText('channel'), '#custom-channel', {
+        waitForElement: false,
+        createOptionText: '#custom-channel',
+      });
+      expect(await screen.findByText('Channel not found')).toBeInTheDocument();
+      expect(screen.getByRole('button', {name: 'Create Project'})).toBeDisabled();
+      await userEvent.click(
+        screen.getByRole('checkbox', {
+          name: /Notify via integration/,
+        })
+      );
+      await waitFor(() => {
+        expect(screen.getByRole('button', {name: 'Create Project'})).toBeEnabled();
+      });
+    });
+
+    it('should show validating tooltip and disable button while validating channel', async () => {
+      renderFrameworkModalMockRequests({
+        organization,
+        teamSlug: teamWithAccess.slug,
+      });
+
+      jest.spyOn(useValidateChannelModule, 'useValidateChannel').mockReturnValue({
+        isFetching: true,
+        clear: jest.fn(),
+        error: undefined,
+      });
+
+      render(<CreateProject />, {organization});
+      await userEvent.click(screen.getByTestId('platform-apple-ios'));
+      await userEvent.click(
+        screen.getByRole('checkbox', {
+          name: /Notify via integration/,
+        })
+      );
+      expect(screen.getByRole('button', {name: 'Create Project'})).toBeDisabled();
+      await userEvent.hover(screen.getByRole('button', {name: 'Create Project'}));
+      expect(
+        await screen.findByText(/Validating integration channel/)
+      ).toBeInTheDocument();
+    });
+
     it('should create an issue alert rule by default', async () => {
       const {projectCreationMockRequest} = renderFrameworkModalMockRequests({
         organization,
diff --git a/static/app/views/projectInstall/createProject.tsx b/static/app/views/projectInstall/createProject.tsx
index 63492cee188a22..6b4a365cd25c1e 100644
--- a/static/app/views/projectInstall/createProject.tsx
+++ b/static/app/views/projectInstall/createProject.tsx
@@ -45,6 +45,7 @@ import {useTeams} from 'sentry/utils/useTeams';
 import {
   MultipleCheckboxOptions,
   useCreateNotificationAction,
+  type IntegrationChannel,
 } from 'sentry/views/projectInstall/issueAlertNotificationOptions';
 import type {
   AlertRuleOptions,
@@ -53,6 +54,7 @@ import type {
 import IssueAlertOptions, {
   getRequestDataFragment,
 } from 'sentry/views/projectInstall/issueAlertOptions';
+import {useValidateChannel} from 'sentry/views/projectInstall/useValidateChannel';
 import {makeProjectsPathname} from 'sentry/views/projects/pathname';
 
 type FormData = {
@@ -82,7 +84,7 @@ function getMissingValues({
   isOrgMemberWithNoAccess: boolean;
   notificationProps: {
     actions?: string[];
-    channel?: string;
+    channel?: IntegrationChannel;
   };
   projectName: string;
   team: string | undefined;
@@ -130,6 +132,7 @@ function getSubmitTooltipText({
   if (isMissingPlatform) {
     return t('Please select a platform');
   }
+
   return t('Please select a team');
 }
 
@@ -141,6 +144,7 @@ export function CreateProject() {
   const location = useLocation();
   const canUserCreateProject = useCanCreateProject();
   const createProjectAndRules = useCreateProjectAndRules();
+
   const {teams} = useTeams();
   const accessTeams = teams.filter((team: Team) => team.access.includes('team:admin'));
   const referrer = decodeScalar(location.query.referrer);
@@ -163,6 +167,12 @@ export function CreateProject() {
     createNotificationActionParam
   );
 
+  const validateChannel = useValidateChannel({
+    channel: notificationProps.channel,
+    integrationId: notificationProps.integration?.id,
+    enabled: false,
+  });
+
   const defaultTeam = accessTeams?.[0]?.slug;
 
   const initialData: FormData = useMemo(() => {
@@ -204,18 +214,26 @@ export function CreateProject() {
     platform: formData.platform,
   });
 
+  const isNotifyingViaIntegration =
+    alertRuleConfig.shouldCreateRule &&
+    notificationProps.actions?.includes(MultipleCheckboxOptions.INTEGRATION);
+
   const formErrorCount = [
     missingValues.isMissingPlatform,
     missingValues.isMissingTeam,
     missingValues.isMissingProjectName,
     missingValues.isMissingAlertThreshold,
     missingValues.isMissingMessagingIntegrationChannel,
+    isNotifyingViaIntegration && validateChannel.error,
   ].filter(value => value).length;
 
-  const submitTooltipText = getSubmitTooltipText({
-    ...missingValues,
-    formErrorCount,
-  });
+  const submitTooltipText =
+    isNotifyingViaIntegration && validateChannel.error
+      ? validateChannel.error
+      : getSubmitTooltipText({
+          ...missingValues,
+          formErrorCount,
+        });
 
   const updateFormData = useCallback(
     <K extends keyof FormData>(field: K, value: FormData[K]) => {
@@ -557,16 +575,25 @@ export function CreateProject() {
               <Tooltip
                 title={
                   canUserCreateProject
-                    ? submitTooltipText
+                    ? isNotifyingViaIntegration && validateChannel.isFetching
+                      ? t('Validating integration channel\u2026')
+                      : submitTooltipText
                     : t('You do not have permission to create projects')
                 }
-                disabled={formErrorCount === 0 && canUserCreateProject}
+                disabled={
+                  formErrorCount === 0 &&
+                  canUserCreateProject &&
+                  !(isNotifyingViaIntegration && validateChannel.isFetching)
+                }
               >
                 <Button
                   data-test-id="create-project"
                   priority="primary"
                   disabled={!(canUserCreateProject && formErrorCount === 0)}
-                  busy={createProjectAndRules.isPending}
+                  busy={
+                    createProjectAndRules.isPending ||
+                    (isNotifyingViaIntegration && validateChannel.isFetching)
+                  }
                   onClick={() => debounceHandleProjectCreation(formData)}
                 >
                   {t('Create Project')}
diff --git a/static/app/views/projectInstall/issueAlertNotificationOptions.spec.tsx b/static/app/views/projectInstall/issueAlertNotificationOptions.spec.tsx
index 5154aa18a72cd8..735bf0e6cb9a97 100644
--- a/static/app/views/projectInstall/issueAlertNotificationOptions.spec.tsx
+++ b/static/app/views/projectInstall/issueAlertNotificationOptions.spec.tsx
@@ -16,7 +16,10 @@ describe('MessagingIntegrationAlertRule', () => {
 
   const notificationProps: IssueAlertNotificationProps = {
     actions: [],
-    channel: 'channel',
+    channel: {
+      label: 'channel',
+      value: 'channel',
+    },
     integration: undefined,
     provider: 'slack',
     providersToIntegrations: {},
diff --git a/static/app/views/projectInstall/issueAlertNotificationOptions.tsx b/static/app/views/projectInstall/issueAlertNotificationOptions.tsx
index e4c0c55515aec2..7548ce87eb5d40 100644
--- a/static/app/views/projectInstall/issueAlertNotificationOptions.tsx
+++ b/static/app/views/projectInstall/issueAlertNotificationOptions.tsx
@@ -63,18 +63,24 @@ export const enum MultipleCheckboxOptions {
   INTEGRATION = 'integration',
 }
 
+export type IntegrationChannel = {
+  label: string;
+  value: string;
+  new?: boolean;
+};
+
 export type IssueAlertNotificationProps = {
   actions: MultipleCheckboxOptions[];
-  channel: string | undefined;
   integration: OrganizationIntegration | undefined;
   provider: string | undefined;
   providersToIntegrations: Record<string, OrganizationIntegration[]>;
   querySuccess: boolean;
   setActions: (action: MultipleCheckboxOptions[]) => void;
-  setChannel: (channel: string | undefined) => void;
+  setChannel: (channel?: IntegrationChannel) => void;
   setIntegration: (integration: OrganizationIntegration | undefined) => void;
   setProvider: (provider: string | undefined) => void;
   shouldRenderSetupButton: boolean;
+  channel?: IntegrationChannel;
 };
 
 export function useCreateNotificationAction({
@@ -109,7 +115,7 @@ export function useCreateNotificationAction({
   const [integration, setIntegration] = useState<OrganizationIntegration | undefined>(
     undefined
   );
-  const [channel, setChannel] = useState<string | undefined>(undefined);
+  const [channel, setChannel] = useState<IntegrationChannel | undefined>(undefined);
   const [shouldRenderSetupButton, setShouldRenderSetupButton] = useState<boolean>(false);
 
   useEffect(() => {
@@ -143,7 +149,10 @@ export function useCreateNotificationAction({
 
     if (firstAction.channel) {
       // eslint-disable-next-line react-you-might-not-need-an-effect/no-derived-state
-      setChannel(firstAction.channel);
+      setChannel({
+        label: firstAction.channel,
+        value: firstAction.channel,
+      });
     }
   }, [defaultActions, providersToIntegrations]);
 
@@ -180,7 +189,7 @@ export function useCreateNotificationAction({
           integrationAction = {
             id: IssueAlertActionType.SLACK,
             workspace: integration?.id,
-            channel,
+            channel: channel?.value,
           };
 
           break;
@@ -188,7 +197,7 @@ export function useCreateNotificationAction({
           integrationAction = {
             id: IssueAlertActionType.DISCORD,
             server: integration?.id,
-            channel_id: channel,
+            channel_id: channel?.value,
           };
 
           break;
@@ -196,7 +205,7 @@ export function useCreateNotificationAction({
           integrationAction = {
             id: IssueAlertActionType.MS_TEAMS,
             team: integration?.id,
-            channel,
+            channel: channel?.value,
           };
           break;
         default:
diff --git a/static/app/views/projectInstall/issueAlertOptions.spec.tsx b/static/app/views/projectInstall/issueAlertOptions.spec.tsx
index cbd3ce97b19331..8fd87963ec7c6e 100644
--- a/static/app/views/projectInstall/issueAlertOptions.spec.tsx
+++ b/static/app/views/projectInstall/issueAlertOptions.spec.tsx
@@ -11,7 +11,10 @@ import IssueAlertOptions, {
 describe('IssueAlertOptions', () => {
   const notificationProps: IssueAlertNotificationProps = {
     actions: [],
-    channel: 'channel',
+    channel: {
+      label: 'channel',
+      value: 'channel',
+    },
     integration: OrganizationIntegrationsFixture(),
     provider: 'slack',
     providersToIntegrations: {},
diff --git a/static/app/views/projectInstall/messagingIntegrationAlertRule.spec.tsx b/static/app/views/projectInstall/messagingIntegrationAlertRule.spec.tsx
index 10dd3f4cfc33c5..77eda22041a2f0 100644
--- a/static/app/views/projectInstall/messagingIntegrationAlertRule.spec.tsx
+++ b/static/app/views/projectInstall/messagingIntegrationAlertRule.spec.tsx
@@ -1,12 +1,31 @@
+import {OrganizationFixture} from 'sentry-fixture/organization';
 import {OrganizationIntegrationsFixture} from 'sentry-fixture/organizationIntegrations';
 
-import {render, screen} from 'sentry-test/reactTestingLibrary';
+import {render, screen, userEvent, waitFor} from 'sentry-test/reactTestingLibrary';
 import selectEvent from 'sentry-test/selectEvent';
 
 import type {IssueAlertNotificationProps} from 'sentry/views/projectInstall/issueAlertNotificationOptions';
 import MessagingIntegrationAlertRule from 'sentry/views/projectInstall/messagingIntegrationAlertRule';
+import * as useValidateChannelModule from 'sentry/views/projectInstall/useValidateChannel';
+
+function setupValidateChannelSpy() {
+  const mockClear = jest.fn();
+  const originalUseValidateChannel = useValidateChannelModule.useValidateChannel;
+  const spy = jest.spyOn(useValidateChannelModule, 'useValidateChannel');
+
+  spy.mockImplementation((...args) => {
+    const result = originalUseValidateChannel(...args);
+    return {
+      ...result,
+      clear: mockClear,
+    };
+  });
+
+  return {mockClear, spy};
+}
 
 describe('MessagingIntegrationAlertRule', () => {
+  const organization = OrganizationFixture();
   const slackIntegrations = [
     OrganizationIntegrationsFixture({
       name: "Moo Deng's Workspace",
@@ -38,7 +57,10 @@ describe('MessagingIntegrationAlertRule', () => {
 
   const notificationProps: IssueAlertNotificationProps = {
     actions: [],
-    channel: 'channel',
+    channel: {
+      label: 'channel',
+      value: 'channel',
+    },
     integration: slackIntegrations[0],
     provider: 'slack',
     providersToIntegrations,
@@ -50,6 +72,15 @@ describe('MessagingIntegrationAlertRule', () => {
     setProvider: mockSetProvider,
   };
 
+  beforeEach(() => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channels/`,
+      body: {
+        results: [],
+      },
+    });
+  });
+
   const getComponent = () => <MessagingIntegrationAlertRule {...notificationProps} />;
 
   it('renders', () => {
@@ -96,4 +127,234 @@ describe('MessagingIntegrationAlertRule', () => {
     );
     expect(screen.getByLabelText('integration')).toBeDisabled();
   });
+
+  it('loads channels', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${discordIntegrations[0]!.id}/channels/`,
+      body: {
+        nextCursor: null,
+        results: [
+          {id: '1', name: 'general', display: '#general', type: 'text'},
+          {id: '2', name: 'alerts', display: '#alerts', type: 'text'},
+        ],
+      },
+    });
+    render(
+      <MessagingIntegrationAlertRule
+        {...{
+          ...notificationProps,
+          integration: discordIntegrations[0],
+          provider: 'discord',
+        }}
+      />
+    );
+    await selectEvent.openMenu(screen.getByLabelText('channel'));
+    expect(await screen.findByText('#alerts')).toBeInTheDocument();
+    expect(screen.getByText('#general')).toBeInTheDocument();
+    await selectEvent.select(screen.getByLabelText('channel'), '#alerts');
+    expect(mockSetChannel).toHaveBeenCalledWith({
+      label: '#alerts',
+      value: '#alerts',
+      new: false,
+    });
+  });
+
+  it('shows empty state when no channels are returned', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${discordIntegrations[0]!.id}/channels/`,
+      body: {
+        nextCursor: null,
+        results: [],
+      },
+    });
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...{
+          ...notificationProps,
+          integration: discordIntegrations[0],
+          provider: 'discord',
+        }}
+      />
+    );
+
+    await selectEvent.openMenu(screen.getByLabelText('channel'));
+    expect(await screen.findByText('No options')).toBeInTheDocument();
+    expect(mockSetChannel).not.toHaveBeenCalled();
+  });
+
+  it('set custom channel as "new" when created', async () => {
+    render(getComponent());
+
+    await selectEvent.create(screen.getByLabelText('channel'), '#custom-channel', {
+      waitForElement: false,
+      createOptionText: '#custom-channel',
+    });
+
+    expect(mockSetChannel).toHaveBeenCalledWith({
+      label: '#custom-channel',
+      value: '#custom-channel',
+      new: true,
+    });
+  });
+
+  it('validates custom channel when created', async () => {
+    const validationRequest = MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channel-validate/`,
+      body: {valid: true},
+    });
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...notificationProps}
+        channel={{label: '#custom-channel', value: 'custom-channel', new: true}}
+      />
+    );
+
+    await waitFor(() => {
+      expect(validationRequest).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          query: {channel: '#custom-channel'},
+        })
+      );
+    });
+  });
+
+  it('displays validation error when channel is invalid', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channel-validate/`,
+      body: {valid: false, detail: 'Channel not found'},
+    });
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...notificationProps}
+        channel={{label: '#invalid-channel', value: '#invalid-channel', new: true}}
+      />
+    );
+
+    expect(await screen.findByText('Channel not found')).toBeInTheDocument();
+  });
+
+  it('displays default error message when validation fails without detail', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channel-validate/`,
+      body: {valid: false},
+    });
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...notificationProps}
+        channel={{label: '#invalid-channel', value: '#invalid-channel', new: true}}
+      />
+    );
+
+    expect(
+      await screen.findByText('Channel not found or restricted')
+    ).toBeInTheDocument();
+  });
+
+  it('displays error when validation request fails', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channel-validate/`,
+      statusCode: 500,
+      body: {detail: 'Internal Error'},
+    });
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...notificationProps}
+        channel={{label: '#invalid-channel', value: '#invalid-channel', new: true}}
+      />
+    );
+
+    expect(
+      await screen.findByText('Unexpected integration channel validation error')
+    ).toBeInTheDocument();
+  });
+
+  it('clears validation error when channel is cleared', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channel-validate/`,
+      body: {valid: false, detail: 'Channel not found'},
+    });
+
+    const {mockClear, spy} = setupValidateChannelSpy();
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...notificationProps}
+        channel={{label: '#invalid-channel', value: '#invalid-channel', new: true}}
+      />
+    );
+
+    expect(await screen.findByText('Channel not found')).toBeInTheDocument();
+    await userEvent.click(screen.getByLabelText('Clear choices'));
+    expect(mockSetChannel).toHaveBeenCalledWith(undefined);
+    expect(mockClear).toHaveBeenCalled();
+
+    spy.mockRestore();
+  });
+
+  it('clears validation error when provider is changed', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channel-validate/`,
+      body: {valid: false, detail: 'Channel not found'},
+    });
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${discordIntegrations[0]!.id}/channels/`,
+      body: {results: []},
+    });
+
+    const {mockClear, spy} = setupValidateChannelSpy();
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...notificationProps}
+        channel={{label: '#invalid-channel', value: '#invalid-channel', new: true}}
+      />
+    );
+
+    expect(await screen.findByText('Channel not found')).toBeInTheDocument();
+
+    await selectEvent.select(screen.getByText('Slack'), 'Discord');
+
+    expect(mockClear).toHaveBeenCalled();
+
+    spy.mockRestore();
+  });
+
+  it('clears validation error when integration is changed', async () => {
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[0]!.id}/channel-validate/`,
+      body: {valid: false, detail: 'Channel not found'},
+    });
+
+    MockApiClient.addMockResponse({
+      url: `/organizations/${organization.slug}/integrations/${slackIntegrations[1]!.id}/channels/`,
+      body: {results: []},
+    });
+
+    const {mockClear, spy} = setupValidateChannelSpy();
+
+    render(
+      <MessagingIntegrationAlertRule
+        {...notificationProps}
+        channel={{label: '#invalid-channel', value: '#invalid-channel', new: true}}
+      />
+    );
+
+    expect(await screen.findByText('Channel not found')).toBeInTheDocument();
+
+    await selectEvent.select(
+      screen.getByText("Moo Deng's Workspace"),
+      "Moo Waan's Workspace"
+    );
+
+    expect(mockClear).toHaveBeenCalled();
+
+    spy.mockRestore();
+  });
 });
diff --git a/static/app/views/projectInstall/messagingIntegrationAlertRule.tsx b/static/app/views/projectInstall/messagingIntegrationAlertRule.tsx
index 9cb48d4c433e53..b4c517102ec9dd 100644
--- a/static/app/views/projectInstall/messagingIntegrationAlertRule.tsx
+++ b/static/app/views/projectInstall/messagingIntegrationAlertRule.tsx
@@ -1,14 +1,32 @@
 import {useMemo} from 'react';
 import styled from '@emotion/styled';
 
-import {Input} from 'sentry/components/core/input';
+import {SelectOption} from '@sentry/scraps/select/option';
+
 import {Select} from 'sentry/components/core/select';
+import {components as SelectComponents} from 'sentry/components/forms/controls/reactSelectWrapper';
+import FormField from 'sentry/components/forms/formField';
 import {t} from 'sentry/locale';
 import {space} from 'sentry/styles/space';
+import type {SelectValue} from 'sentry/types/core';
+import {useApiQuery} from 'sentry/utils/queryClient';
+import useOrganization from 'sentry/utils/useOrganization';
 import {
   providerDetails,
   type IssueAlertNotificationProps,
 } from 'sentry/views/projectInstall/issueAlertNotificationOptions';
+import {useValidateChannel} from 'sentry/views/projectInstall/useValidateChannel';
+
+type Channel = {
+  display: string;
+  id: string;
+  name: string;
+  type: string;
+};
+
+type ChannelListResponse = {
+  results: Channel[];
+};
 
 export default function MessagingIntegrationAlertRule({
   channel,
@@ -19,6 +37,22 @@ export default function MessagingIntegrationAlertRule({
   setProvider,
   providersToIntegrations,
 }: IssueAlertNotificationProps) {
+  const organization = useOrganization();
+
+  const {data: channels, isPending} = useApiQuery<ChannelListResponse>(
+    [`/organizations/${organization.slug}/integrations/${integration?.id}/channels/`],
+    {
+      staleTime: Infinity,
+      enabled: !!provider && !!integration?.id,
+    }
+  );
+
+  const validateChannel = useValidateChannel({
+    channel,
+    integrationId: integration?.id,
+    enabled: !!integration?.id && !!channel?.new,
+  });
+
   const providerOptions = useMemo(
     () =>
       Object.keys(providersToIntegrations).map(p => ({
@@ -54,7 +88,8 @@ export default function MessagingIntegrationAlertRule({
             onChange={(p: any) => {
               setProvider(p.value);
               setIntegration(providersToIntegrations[p.value]![0]);
-              setChannel('');
+              setChannel(undefined);
+              validateChannel.clear();
             }}
           />
         ),
@@ -64,21 +99,68 @@ export default function MessagingIntegrationAlertRule({
             disabled={integrationOptions.length === 1}
             value={integration}
             options={integrationOptions}
-            onChange={(i: any) => setIntegration(i.value)}
+            onChange={(i: any) => {
+              setIntegration(i.value);
+              setChannel(undefined);
+              validateChannel.clear();
+            }}
           />
         ),
         target: (
-          <InlineInput
-            aria-label={t('channel')}
-            type="text"
-            value={channel || ''}
-            placeholder={
-              providerDetails[provider as keyof typeof providerDetails]?.placeholder
-            }
-            onChange={(e: React.ChangeEvent<HTMLInputElement>) =>
-              setChannel(e.target.value)
-            }
-          />
+          <ChannelField name="channel" error={validateChannel.error} inline={false}>
+            {() => (
+              <InlineSelect
+                aria-label={t('channel')}
+                placeholder={
+                  providerDetails[provider as keyof typeof providerDetails]?.placeholder
+                }
+                isSearchable
+                options={channels?.results.map(ch => ({
+                  label: ch.display,
+                  value: ch.display,
+                }))}
+                isLoading={isPending || validateChannel.isFetching}
+                disabled={!integration}
+                value={channel ? {label: channel.label, value: channel.value} : undefined}
+                onChange={(
+                  option: (SelectValue<string> & {label: string}) | undefined
+                ) => {
+                  if (option) {
+                    setChannel({value: option.value, label: option.label, new: false});
+                  } else {
+                    setChannel(undefined);
+                  }
+                  validateChannel.clear();
+                }}
+                onCreateOption={(newOption: string) => {
+                  setChannel({value: newOption, label: newOption, new: true});
+                }}
+                clearable
+                // The Slack API returns the maximum of channels, and users might not find the channel they want in the first 1000.
+                // This allows them to add a channel that is not present in the results.
+                creatable
+                formatCreateLabel={(inputValue: string) => inputValue}
+                menuPlacement="auto"
+                components={{
+                  Option: (
+                    optionProps: React.ComponentProps<typeof SelectComponents.Option>
+                  ) => {
+                    return (
+                      <SelectOption
+                        {...optionProps}
+                        data={{
+                          ...optionProps.data,
+                          // Hide IconAdd for new channel options by setting __isNew__ to false
+                          // We are doing that to don't give the impression that the user can create a new channel.
+                          __isNew__: false,
+                        }}
+                      />
+                    );
+                  },
+                }}
+              />
+            )}
+          </ChannelField>
         ),
       })}
     </Rule>
@@ -90,6 +172,7 @@ const Rule = styled('div')`
   background-color: ${p => p.theme.backgroundSecondary};
   border-radius: ${p => p.theme.borderRadius};
   display: flex;
+  flex-wrap: wrap;
   align-items: center;
   gap: ${space(1)};
 `;
@@ -98,7 +181,10 @@ const InlineSelectControl = styled(Select)`
   width: 180px;
 `;
 
-const InlineInput = styled(Input)`
-  width: auto;
-  min-height: 28px;
+const InlineSelect = styled(Select)`
+  min-width: 220px;
+`;
+
+const ChannelField = styled(FormField)`
+  padding: 0;
 `;
diff --git a/static/app/views/projectInstall/useValidateChannel.ts b/static/app/views/projectInstall/useValidateChannel.ts
new file mode 100644
index 00000000000000..ad6526399dafed
--- /dev/null
+++ b/static/app/views/projectInstall/useValidateChannel.ts
@@ -0,0 +1,58 @@
+import {useMemo} from 'react';
+
+import {t} from 'sentry/locale';
+import {useApiQuery, useQueryClient, type ApiQueryKey} from 'sentry/utils/queryClient';
+import useOrganization from 'sentry/utils/useOrganization';
+import type {IntegrationChannel} from 'sentry/views/projectInstall/issueAlertNotificationOptions';
+
+type Response = {
+  valid: boolean;
+  detail?: string;
+};
+
+/**
+ * Checks whether a manually entered integration channel (e.g., Slack channel, Discord server) is valid.
+ */
+export function useValidateChannel({
+  channel,
+  integrationId,
+  enabled,
+}: {
+  enabled: boolean;
+  channel?: IntegrationChannel;
+  integrationId?: string;
+}) {
+  const organization = useOrganization();
+  const queryClient = useQueryClient();
+
+  const queryKey: ApiQueryKey = useMemo(
+    () => [
+      `/organizations/${organization.slug}/integrations/${integrationId}/channel-validate/`,
+      {
+        query: {
+          channel: channel?.label,
+        },
+      },
+    ],
+    [organization.slug, integrationId, channel?.label]
+  );
+
+  const {isFetching, data, error} = useApiQuery<Response>(queryKey, {
+    staleTime: 0,
+    enabled,
+  });
+
+  return {
+    isFetching,
+    clear: () =>
+      queryClient.removeQueries({
+        queryKey,
+      }),
+    error:
+      data?.valid === false
+        ? (data.detail ?? t('Channel not found or restricted'))
+        : error
+          ? t('Unexpected integration channel validation error')
+          : undefined,
+  };
+}