diff --git a/source/CPDLCPlugin/Messages/OpenConnectionRequestWindowRequest.cs b/source/CPDLCPlugin/Messages/OpenConnectionRequestWindowRequest.cs
new file mode 100644
index 0000000..2d705f2
--- /dev/null
+++ b/source/CPDLCPlugin/Messages/OpenConnectionRequestWindowRequest.cs
@@ -0,0 +1,50 @@
+using CPDLCPlugin.Configuration;
+using CPDLCPlugin.ViewModels;
+using CPDLCPlugin.Windows;
+using MediatR;
+
+namespace CPDLCPlugin.Messages;
+
+public record OpenConnectionRequestWindowRequest(string Callsign) : IRequest;
+
+public class OpenConnectionRequestWindowRequestHandler(
+    WindowManager windowManager,
+    PluginConfiguration pluginConfiguration,
+    IMediator mediator,
+    Plugin plugin,
+    IErrorReporter errorReporter)
+    : IRequestHandler<OpenConnectionRequestWindowRequest>
+{
+    public Task Handle(OpenConnectionRequestWindowRequest request, CancellationToken cancellationToken)
+    {
+        // Each window is specific to a callsign, so we always want a fresh window
+        windowManager.TryRemoveWindow(WindowKeys.ConnectionRequest);
+
+        windowManager.FocusOrCreateWindow(
+            WindowKeys.ConnectionRequest,
+            "CPDLC Connection Request",
+            windowHandle =>
+            {
+                var currentStationIdentifier = plugin.ConnectionManager?.StationIdentifier;
+                var viewModel = new ConnectionRequestViewModel(
+                    mediator,
+                    errorReporter,
+                    windowHandle,
+                    request.Callsign,
+                    pluginConfiguration.Stations,
+                    string.IsNullOrEmpty(currentStationIdentifier) ? pluginConfiguration.Stations.First() : currentStationIdentifier!);
+
+                var control = new ConnectionRequestView(viewModel);
+                return control;
+            },
+            configureForm: form =>
+            {
+                form.HasMinimizeButton = false;
+                form.MinimizeBox = false;
+                form.HasCloseButton = false;
+                form.HasSendBackButton = false;
+            });
+
+        return Task.CompletedTask;
+    }
+}
diff --git a/source/CPDLCPlugin/Messages/RebuildCpdlcStatusLabelItemsRequest.cs b/source/CPDLCPlugin/Messages/RebuildCpdlcStatusLabelItemsRequest.cs
index ea689f4..feb5399 100644
--- a/source/CPDLCPlugin/Messages/RebuildCpdlcStatusLabelItemsRequest.cs
+++ b/source/CPDLCPlugin/Messages/RebuildCpdlcStatusLabelItemsRequest.cs
@@ -84,7 +84,21 @@ public async Task Handle(RebuildCpdlcStatusLabelItemsRequest request, Cancellati
                     if (isOnAcarsNetwork && connection is null)
                     {
                         text = ".";
-                        // TODO: Left click will initiate a manual connection
+                        onMouseClick = args =>
+                        {
+                            try
+                            {
+                                if (args.Button != CustomLabelItemMouseButton.Left)
+                                    return;
+
+                                mediator.Send(new OpenConnectionRequestWindowRequest(callsign));
+                                args.Handled = true;
+                            }
+                            catch (Exception ex)
+                            {
+                                errorReporter.ReportError(ex, "Error opening CPDLC connection request window");
+                            }
+                        };
                     }
                     else if (connection is not null && connection.DataAuthorityState == DataAuthorityState.NextDataAuthority)
                     {
diff --git a/source/CPDLCPlugin/Messages/SendConnectionRequestRequest.cs b/source/CPDLCPlugin/Messages/SendConnectionRequestRequest.cs
new file mode 100644
index 0000000..a482da2
--- /dev/null
+++ b/source/CPDLCPlugin/Messages/SendConnectionRequestRequest.cs
@@ -0,0 +1,26 @@
+using MediatR;
+using Serilog;
+
+namespace CPDLCPlugin.Messages;
+
+public record SendConnectionRequestRequest(string Callsign, string StationId) : IRequest;
+
+public class SendConnectionRequestRequestHandler(Plugin plugin, ILogger logger)
+    : IRequestHandler<SendConnectionRequestRequest>
+{
+    public async Task Handle(SendConnectionRequestRequest request, CancellationToken cancellationToken)
+    {
+        logger.Information("Sending connection request for {StationId} to {Callsign}", request.StationId, request.Callsign);
+
+        if (plugin.ConnectionManager is null || !plugin.ConnectionManager.IsConnected)
+        {
+            logger.Warning("Not connected to server");
+            return;
+        }
+
+        await plugin.ConnectionManager.RequestConnection(
+            request.Callsign,
+            request.StationId,
+            cancellationToken);
+    }
+}
diff --git a/source/CPDLCPlugin/Server/SignalRConnectionManager.cs b/source/CPDLCPlugin/Server/SignalRConnectionManager.cs
index 618d1fb..ba93224 100644
--- a/source/CPDLCPlugin/Server/SignalRConnectionManager.cs
+++ b/source/CPDLCPlugin/Server/SignalRConnectionManager.cs
@@ -180,6 +180,16 @@ await connection.InvokeAsync<UplinkMessageDto>(
             cancellationToken: cancellationToken);
     }
 
+    public async Task RequestConnection(string callsign, string stationId, CancellationToken cancellationToken)
+    {
+        var connection = GetConnectedOrThrow();
+        await connection.InvokeAsync(
+            "RequestConnection",
+            callsign,
+            stationId,
+            cancellationToken);
+    }
+
     public async Task<AircraftConnectionDto[]> GetConnectedAircraft(CancellationToken cancellationToken)
     {
         var connection = GetConnectedOrThrow();
diff --git a/source/CPDLCPlugin/ViewModels/ConnectionRequestViewModel.cs b/source/CPDLCPlugin/ViewModels/ConnectionRequestViewModel.cs
new file mode 100644
index 0000000..f570ca2
--- /dev/null
+++ b/source/CPDLCPlugin/ViewModels/ConnectionRequestViewModel.cs
@@ -0,0 +1,61 @@
+using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using CPDLCPlugin.Messages;
+using MediatR;
+
+namespace CPDLCPlugin.ViewModels;
+
+public partial class ConnectionRequestViewModel : ObservableObject
+{
+    readonly IMediator _mediator;
+    readonly IErrorReporter _errorReporter;
+    readonly IWindowHandle _windowHandle;
+
+    [ObservableProperty] string callsign;
+    [ObservableProperty] string[] availableStationIdentifiers;
+    [ObservableProperty] string selectedStationIdentifier;
+
+    // Example data for the XAML designer. Do not use at runtime.
+    public ConnectionRequestViewModel()
+    {
+        Callsign = "QFA123AB";
+        AvailableStationIdentifiers = ["YBBB", "YMMM"];
+        SelectedStationIdentifier = "YBBB";
+    }
+
+    public ConnectionRequestViewModel(
+        IMediator mediator,
+        IErrorReporter errorReporter,
+        IWindowHandle windowHandle,
+        string callsign,
+        string[] availableStationIdentifiers,
+        string selectedStationIdentifier)
+    {
+        _mediator = mediator;
+        _errorReporter = errorReporter;
+        _windowHandle = windowHandle;
+        Callsign = callsign;
+        AvailableStationIdentifiers = availableStationIdentifiers;
+        SelectedStationIdentifier = selectedStationIdentifier;
+    }
+
+    [RelayCommand]
+    async Task Confirm()
+    {
+        try
+        {
+            await _mediator.Send(new SendConnectionRequestRequest(Callsign, SelectedStationIdentifier));
+            _windowHandle.Close();
+        }
+        catch (Exception e)
+        {
+            _errorReporter.ReportError(e);
+        }
+    }
+
+    [RelayCommand]
+    void Cancel()
+    {
+        _windowHandle.Close();
+    }
+}
diff --git a/source/CPDLCPlugin/Windows/ConnectionRequestView.xaml b/source/CPDLCPlugin/Windows/ConnectionRequestView.xaml
new file mode 100644
index 0000000..8bd5696
--- /dev/null
+++ b/source/CPDLCPlugin/Windows/ConnectionRequestView.xaml
@@ -0,0 +1,75 @@
+<UserControl x:Class="CPDLCPlugin.Windows.ConnectionRequestView"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:cpdlcPlugin="clr-namespace:CPDLCPlugin"
+        xmlns:viewModels="clr-namespace:CPDLCPlugin.ViewModels"
+        Background="{x:Static cpdlcPlugin:Theme.BackgroundColor}"
+        d:DataContext="{d:DesignInstance Type=viewModels:ConnectionRequestViewModel}"
+        mc:Ignorable="d"
+        Width="400">
+    <UserControl.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceDictionary Source="/CPDLCPlugin;component/Styles.xaml" />
+            </ResourceDictionary.MergedDictionaries>
+
+            <Style TargetType="Button" BasedOn="{StaticResource ButtonBaseStyle}">
+                <Setter Property="Height" Value="32"/>
+                <Setter Property="MinWidth" Value="80"/>
+            </Style>
+
+            <Style TargetType="TextBlock" BasedOn="{StaticResource GenericTextStyle}" />
+        </ResourceDictionary>
+    </UserControl.Resources>
+
+    <Grid Margin="16">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+            <RowDefinition Height="Auto"/>
+        </Grid.RowDefinitions>
+
+        <TextBlock Grid.Row="0" Margin="0,0,0,8" TextWrapping="Wrap">
+            <Run Text="Send connection request to "/>
+            <Run Text="{Binding Callsign, Mode=OneWay}"/>
+        </TextBlock>
+
+        <!-- ATSU -->
+        <Grid Grid.Row="1" Margin="0,0,0,8">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+
+            <TextBlock Grid.Column="0" Text="ATSU" Margin="0,0,8,0"/>
+            <ComboBox Grid.Column="1"
+                      ItemsSource="{Binding AvailableStationIdentifiers}"
+                      SelectedItem="{Binding SelectedStationIdentifier}"/>
+        </Grid>
+
+        <!-- Buttons -->
+        <Grid Grid.Row="3">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="*"/>
+                <ColumnDefinition Width="*"/>
+            </Grid.ColumnDefinitions>
+
+            <Button
+                Grid.Column="0"
+                Content="Send"
+                Command="{Binding ConfirmCommand}"
+                HorizontalAlignment="Stretch"
+                Margin="0,0,4,0"/>
+
+            <Button
+                Grid.Column="1"
+                Content="Cancel"
+                Command="{Binding CancelCommand}"
+                HorizontalAlignment="Stretch"
+                Margin="4,0,0,0"/>
+        </Grid>
+    </Grid>
+</UserControl>
diff --git a/source/CPDLCPlugin/Windows/ConnectionRequestView.xaml.cs b/source/CPDLCPlugin/Windows/ConnectionRequestView.xaml.cs
new file mode 100644
index 0000000..69a3a15
--- /dev/null
+++ b/source/CPDLCPlugin/Windows/ConnectionRequestView.xaml.cs
@@ -0,0 +1,13 @@
+using System.Windows.Controls;
+using CPDLCPlugin.ViewModels;
+
+namespace CPDLCPlugin.Windows;
+
+public partial class ConnectionRequestView : UserControl
+{
+    public ConnectionRequestView(ConnectionRequestViewModel viewModel)
+    {
+        InitializeComponent();
+        DataContext = viewModel;
+    }
+}
diff --git a/source/CPDLCPlugin/Windows/WindowKeys.cs b/source/CPDLCPlugin/Windows/WindowKeys.cs
index b1dacf4..3e04d8f 100644
--- a/source/CPDLCPlugin/Windows/WindowKeys.cs
+++ b/source/CPDLCPlugin/Windows/WindowKeys.cs
@@ -7,4 +7,5 @@ public static class WindowKeys
     public const string CurrentMessages = nameof(CurrentMessages);
     public const string History = nameof(History);
     public const string ADSContract = nameof(ADSContract);
+    public const string ConnectionRequest = nameof(ConnectionRequest);
 }
\ No newline at end of file
diff --git a/source/CPDLCServer.Tests/Handlers/SendConnectionRequestCommandHandlerTests.cs b/source/CPDLCServer.Tests/Handlers/SendConnectionRequestCommandHandlerTests.cs
new file mode 100644
index 0000000..d091993
--- /dev/null
+++ b/source/CPDLCServer.Tests/Handlers/SendConnectionRequestCommandHandlerTests.cs
@@ -0,0 +1,103 @@
+using CPDLCServer.Handlers;
+using CPDLCServer.Messages;
+using CPDLCServer.Model;
+using CPDLCServer.Tests.Mocks;
+using Serilog.Core;
+
+namespace CPDLCServer.Tests.Handlers;
+
+public class SendConnectionRequestCommandHandlerTests
+{
+    [Fact]
+    public async Task Handle_SendsConnectionRequestUplink()
+    {
+        // Arrange
+        var clientManager = new TestClientManager();
+        var messageIdProvider = new TestMessageIdProvider();
+        messageIdProvider.SetNextId(5);
+        var clock = new TestClock();
+
+        var handler = new SendConnectionRequestCommandHandler(clientManager, messageIdProvider, clock, Logger.None);
+
+        var command = new SendConnectionRequestCommand("UAL123", "YBBB");
+
+        // Act
+        await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        var client = (TestAcarsClient)await clientManager.GetAcarsClient("hoppies-ybbb", CancellationToken.None);
+        var uplink = Assert.Single(client.SentMessages);
+        Assert.Equal("UAL123", uplink.Recipient);
+        Assert.Equal("CONNECTION REQUESTED @YBBB@", uplink.Content);
+        Assert.Equal(5, uplink.MessageId);
+        Assert.Null(uplink.MessageReference);
+        Assert.Equal(CpdlcUplinkResponseType.NoResponse, uplink.ResponseType);
+        Assert.Equal(clock.UtcNow(), uplink.Sent);
+    }
+
+    [Fact]
+    public async Task Handle_SendsUplinkViaClientForSelectedStation()
+    {
+        // The uplink must go through the ACARS client of the selected ATSU, not another client.
+        // Arrange
+        var clientManager = new TestClientManager();
+        var messageIdProvider = new TestMessageIdProvider();
+        var clock = new TestClock();
+
+        var handler = new SendConnectionRequestCommandHandler(clientManager, messageIdProvider, clock, Logger.None);
+
+        var command = new SendConnectionRequestCommand("UAL123", "YMMM");
+
+        // Act
+        await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        var ymmmClient = (TestAcarsClient)await clientManager.GetAcarsClient("hoppies-ymmm", CancellationToken.None);
+        var ybbbClient = (TestAcarsClient)await clientManager.GetAcarsClient("hoppies-ybbb", CancellationToken.None);
+
+        var uplink = Assert.Single(ymmmClient.SentMessages);
+        Assert.Equal("CONNECTION REQUESTED @YMMM@", uplink.Content);
+        Assert.Empty(ybbbClient.SentMessages);
+    }
+
+    [Fact]
+    public async Task Handle_MatchesStationIdIgnoringCase()
+    {
+        // Arrange
+        var clientManager = new TestClientManager();
+        var messageIdProvider = new TestMessageIdProvider();
+        var clock = new TestClock();
+
+        var handler = new SendConnectionRequestCommandHandler(clientManager, messageIdProvider, clock, Logger.None);
+
+        var command = new SendConnectionRequestCommand("UAL123", "ybbb");
+
+        // Act
+        await handler.Handle(command, CancellationToken.None);
+
+        // Assert
+        var client = (TestAcarsClient)await clientManager.GetAcarsClient("hoppies-ybbb", CancellationToken.None);
+        Assert.Single(client.SentMessages);
+    }
+
+    [Fact]
+    public async Task Handle_ThrowsWhenNoClientForStation()
+    {
+        // Arrange
+        var clientManager = new TestClientManager();
+        var messageIdProvider = new TestMessageIdProvider();
+        var clock = new TestClock();
+
+        var handler = new SendConnectionRequestCommandHandler(clientManager, messageIdProvider, clock, Logger.None);
+
+        var command = new SendConnectionRequestCommand("UAL123", "YPPP");
+
+        // Act & Assert
+        await Assert.ThrowsAnyAsync<Exception>(() => handler.Handle(command, CancellationToken.None));
+
+        var ybbbClient = (TestAcarsClient)await clientManager.GetAcarsClient("hoppies-ybbb", CancellationToken.None);
+        var ymmmClient = (TestAcarsClient)await clientManager.GetAcarsClient("hoppies-ymmm", CancellationToken.None);
+        Assert.Empty(ybbbClient.SentMessages);
+        Assert.Empty(ymmmClient.SentMessages);
+    }
+}
diff --git a/source/CPDLCServer.Tests/Mocks/TestClientManager.cs b/source/CPDLCServer.Tests/Mocks/TestClientManager.cs
index 48d6328..a2ac026 100644
--- a/source/CPDLCServer.Tests/Mocks/TestClientManager.cs
+++ b/source/CPDLCServer.Tests/Mocks/TestClientManager.cs
@@ -70,6 +70,16 @@ public Task<AcarsConfiguration> GetConfigurationForStation(string stationId, Can
         return Task.FromResult(configuration);
     }
 
+    public Task<string?> FindAcarsClientId(string stationId, CancellationToken cancellationToken)
+    {
+        var acarsClientId = _clients
+            .Where(c => string.Equals(c.Value.StationId, stationId, StringComparison.OrdinalIgnoreCase))
+            .Select(c => c.Key)
+            .FirstOrDefault();
+
+        return Task.FromResult(acarsClientId);
+    }
+
     public bool ClientExists(string acarsClientId)
     {
         return _clients.ContainsKey(acarsClientId);
diff --git a/source/CPDLCServer/Clients/ClientManager.cs b/source/CPDLCServer/Clients/ClientManager.cs
index 6b9a7e8..cf99337 100644
--- a/source/CPDLCServer/Clients/ClientManager.cs
+++ b/source/CPDLCServer/Clients/ClientManager.cs
@@ -12,6 +12,7 @@ public interface IClientManager
     Task<IAcarsClient> GetAcarsClient(string acarsClientId, CancellationToken cancellationToken);
     Task<IAcarsClient> GetAcarsClientForStation(string stationId, CancellationToken cancellationToken);
     Task<AcarsConfiguration> GetConfigurationForStation(string stationId, CancellationToken cancellationToken);
+    Task<string?> FindAcarsClientId(string stationId, CancellationToken cancellationToken);
 }
 
 public class ClientManager : BackgroundService, IClientManager
@@ -160,6 +161,16 @@ public Task<AcarsConfiguration> GetConfigurationForStation(string stationId, Can
         return Task.FromResult(configuration);
     }
 
+    public Task<string?> FindAcarsClientId(string stationId, CancellationToken cancellationToken)
+    {
+        var acarsClientId = _clients
+            .Where(c => string.Equals(c.Value.Client.StationId, stationId, StringComparison.OrdinalIgnoreCase))
+            .Select(c => c.Key)
+            .FirstOrDefault();
+
+        return Task.FromResult(acarsClientId);
+    }
+
     async Task<AcarsClientHandle> CreateAcarsClient(string acarsClientId, CancellationToken cancellationToken)
     {
         var configuration = _acarsConfigurations.FirstOrDefault(c => c.ClientId == acarsClientId);
diff --git a/source/CPDLCServer/Handlers/SendConnectionRequestCommandHandler.cs b/source/CPDLCServer/Handlers/SendConnectionRequestCommandHandler.cs
new file mode 100644
index 0000000..340681d
--- /dev/null
+++ b/source/CPDLCServer/Handlers/SendConnectionRequestCommandHandler.cs
@@ -0,0 +1,45 @@
+using CPDLCServer.Clients;
+using CPDLCServer.Infrastructure;
+using CPDLCServer.Messages;
+using CPDLCServer.Model;
+using CPDLCServer.Services;
+using MediatR;
+
+namespace CPDLCServer.Handlers;
+
+public class SendConnectionRequestCommandHandler(
+    IClientManager clientManager,
+    IMessageIdProvider messageIdProvider,
+    IClock clock,
+    ILogger logger)
+    : IRequestHandler<SendConnectionRequestCommand>
+{
+    public async Task Handle(SendConnectionRequestCommand request, CancellationToken cancellationToken)
+    {
+        var acarsClientId = await clientManager.FindAcarsClientId(request.StationId, cancellationToken);
+        if (acarsClientId is null)
+            throw new Exception($"No ACARS client is configured for {request.StationId}");
+
+        var client = await clientManager.GetAcarsClient(acarsClientId, cancellationToken);
+
+        var messageId = await messageIdProvider.GetNextMessageId(
+            acarsClientId,
+            request.Callsign,
+            cancellationToken);
+
+        // This is a system message. It does not start a dialogue.
+        var uplinkMessage = new UplinkMessage(
+            Guid.Empty,
+            messageId,
+            null,
+            request.Callsign,
+            "SYSTEM",
+            CpdlcUplinkResponseType.NoResponse,
+            AlertType.None,
+            $"CONNECTION REQUESTED @{request.StationId}@",
+            clock.UtcNow());
+
+        await client.Send(uplinkMessage, cancellationToken);
+        logger.Information("Sent connection request for {StationId} to {Callsign}", request.StationId, request.Callsign);
+    }
+}
diff --git a/source/CPDLCServer/Hubs/ControllerHub.cs b/source/CPDLCServer/Hubs/ControllerHub.cs
index 8d59426..c45a8fd 100644
--- a/source/CPDLCServer/Hubs/ControllerHub.cs
+++ b/source/CPDLCServer/Hubs/ControllerHub.cs
@@ -129,6 +129,24 @@ await mediator.Send(new ReplyToDownlinkCommand(
             content));
     }
 
+    public async Task RequestConnection(string callsign, string stationId)
+    {
+        var controller = await controllerRepository.FindByConnectionId(Context.ConnectionId, CancellationToken.None);
+        if (controller is null)
+        {
+            _logger.Warning("Controller not found for connection {ConnectionId}", Context.ConnectionId);
+            throw new InvalidOperationException($"Controller not found for connection {Context.ConnectionId}");
+        }
+
+        await mediator.Send(new SendConnectionRequestCommand(callsign, stationId));
+
+        _logger.Information(
+            "Controller {Callsign} requested a connection between {AircraftCallsign} and {StationId}",
+            controller.Callsign,
+            callsign,
+            stationId);
+    }
+
     public async Task<AircraftConnectionDto[]> GetConnectedAircraft()
     {
         var controller = await controllerRepository.FindByConnectionId(Context.ConnectionId, CancellationToken.None);
diff --git a/source/CPDLCServer/Messages/SendConnectionRequestCommand.cs b/source/CPDLCServer/Messages/SendConnectionRequestCommand.cs
new file mode 100644
index 0000000..17e9a06
--- /dev/null
+++ b/source/CPDLCServer/Messages/SendConnectionRequestCommand.cs
@@ -0,0 +1,8 @@
+using MediatR;
+
+namespace CPDLCServer.Messages;
+
+public record SendConnectionRequestCommand(
+    string Callsign,
+    string StationId)
+    : IRequest;