diff --git a/JDBC.NET.Data/JDBC.NET.Data.csproj b/JDBC.NET.Data/JDBC.NET.Data.csproj
index 336d6a0..3cc1675 100644
--- a/JDBC.NET.Data/JDBC.NET.Data.csproj
+++ b/JDBC.NET.Data/JDBC.NET.Data.csproj
@@ -10,14 +10,14 @@
     <RepositoryUrl>https://github.com/chequer-io/JDBC.NET</RepositoryUrl>
     <PackageProjectUrl>https://github.com/chequer-io/JDBC.NET</PackageProjectUrl>
     <PackageIcon>Logo.jpg</PackageIcon>
-    <Version>3.5.8</Version>
+    <Version>3.5.9</Version>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
 
   <ItemGroup>
     <PackageReference Include="J2NET" Version="1.3.2" />
     <PackageReference Include="Google.Protobuf" Version="3.22.3" />
-    <PackageReference Include="Grpc" Version="2.46.6" />
+    <PackageReference Include="Grpc.Net.Client" Version="2.61.0" />
     <PackageReference Include="Grpc.Tools" Version="2.54.0">
         <PrivateAssets>all</PrivateAssets>
         <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/JDBC.NET.Data/JdbcCallInterceptor.cs b/JDBC.NET.Data/JdbcCallInterceptor.cs
new file mode 100644
index 0000000..b91e7d8
--- /dev/null
+++ b/JDBC.NET.Data/JdbcCallInterceptor.cs
@@ -0,0 +1,171 @@
+using System.Threading;
+using System.Threading.Tasks;
+using Grpc.Core;
+using Grpc.Core.Interceptors;
+using JDBC.NET.Data.Exceptions;
+
+namespace JDBC.NET.Data;
+
+internal sealed class JdbcCallInterceptor : Interceptor
+{
+    public override TResponse BlockingUnaryCall<TRequest, TResponse>(TRequest request, ClientInterceptorContext<TRequest, TResponse> context, BlockingUnaryCallContinuation<TRequest, TResponse> continuation)
+    {
+        try
+        {
+            return base.BlockingUnaryCall(request, context, continuation);
+        }
+        catch (RpcException e)
+        {
+            throw new JdbcException(e);
+        }
+    }
+
+    public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(TRequest request, ClientInterceptorContext<TRequest, TResponse> context, AsyncUnaryCallContinuation<TRequest, TResponse> continuation)
+    {
+        AsyncUnaryCall<TResponse> asyncCall = base.AsyncUnaryCall(request, context, continuation);
+
+        return new AsyncUnaryCall<TResponse>(
+            Wrap(asyncCall.ResponseAsync),
+            Wrap(asyncCall.ResponseHeadersAsync),
+            asyncCall.GetStatus,
+            asyncCall.GetTrailers,
+            asyncCall.Dispose
+        );
+    }
+
+    public override AsyncClientStreamingCall<TRequest, TResponse> AsyncClientStreamingCall<TRequest, TResponse>(ClientInterceptorContext<TRequest, TResponse> context, AsyncClientStreamingCallContinuation<TRequest, TResponse> continuation)
+    {
+        AsyncClientStreamingCall<TRequest, TResponse> asyncCall = base.AsyncClientStreamingCall(context, continuation);
+
+        return new AsyncClientStreamingCall<TRequest, TResponse>(
+            Wrap(asyncCall.RequestStream),
+            Wrap(asyncCall.ResponseAsync),
+            Wrap(asyncCall.ResponseHeadersAsync),
+            asyncCall.GetStatus,
+            asyncCall.GetTrailers,
+            asyncCall.Dispose
+        );
+    }
+
+    public override AsyncDuplexStreamingCall<TRequest, TResponse> AsyncDuplexStreamingCall<TRequest, TResponse>(ClientInterceptorContext<TRequest, TResponse> context, AsyncDuplexStreamingCallContinuation<TRequest, TResponse> continuation)
+    {
+        AsyncDuplexStreamingCall<TRequest, TResponse> asyncCall = base.AsyncDuplexStreamingCall(context, continuation);
+
+        return new AsyncDuplexStreamingCall<TRequest, TResponse>(
+            Wrap(asyncCall.RequestStream),
+            Wrap(asyncCall.ResponseStream),
+            Wrap(asyncCall.ResponseHeadersAsync),
+            asyncCall.GetStatus,
+            asyncCall.GetTrailers,
+            asyncCall.Dispose
+        );
+    }
+
+    public override AsyncServerStreamingCall<TResponse> AsyncServerStreamingCall<TRequest, TResponse>(TRequest request, ClientInterceptorContext<TRequest, TResponse> context, AsyncServerStreamingCallContinuation<TRequest, TResponse> continuation)
+    {
+        AsyncServerStreamingCall<TResponse> asyncCall = base.AsyncServerStreamingCall(request, context, continuation);
+
+        return new AsyncServerStreamingCall<TResponse>(
+            Wrap(asyncCall.ResponseStream),
+            Wrap(asyncCall.ResponseHeadersAsync),
+            asyncCall.GetStatus,
+            asyncCall.GetTrailers,
+            asyncCall.Dispose
+        );
+    }
+
+    private static async Task<T> Wrap<T>(Task<T> task)
+    {
+        if (task.Status != TaskStatus.WaitingForActivation)
+            return await task;
+
+        try
+        {
+            return await task;
+        }
+        catch (RpcException e)
+        {
+            throw new JdbcException(e);
+        }
+    }
+
+    private static IClientStreamWriter<T> Wrap<T>(IClientStreamWriter<T> writer)
+    {
+        if (writer == null)
+            return null;
+
+        return new JdbcClientStreamWriter<T>(writer);
+    }
+
+    private static IAsyncStreamReader<T> Wrap<T>(IAsyncStreamReader<T> reader)
+    {
+        if (reader == null)
+            return null;
+
+        return new JdbcAsyncStreamReader<T>(reader);
+    }
+
+    private readonly struct JdbcClientStreamWriter<T> : IClientStreamWriter<T>
+    {
+        public WriteOptions WriteOptions
+        {
+            get => _writer.WriteOptions;
+            set => _writer.WriteOptions = value;
+        }
+
+        private readonly IClientStreamWriter<T> _writer;
+
+        public JdbcClientStreamWriter(IClientStreamWriter<T> writer)
+        {
+            _writer = writer;
+        }
+
+        public async Task WriteAsync(T message)
+        {
+            try
+            {
+                await _writer.WriteAsync(message);
+            }
+            catch (RpcException e)
+            {
+                throw new JdbcException(e);
+            }
+        }
+
+        public async Task CompleteAsync()
+        {
+            try
+            {
+                await _writer.CompleteAsync();
+            }
+            catch (RpcException e)
+            {
+                throw new JdbcException(e);
+            }
+        }
+    }
+
+    private readonly struct JdbcAsyncStreamReader<T> : IAsyncStreamReader<T>
+    {
+        public T Current => _reader.Current;
+
+        private readonly IAsyncStreamReader<T> _reader;
+
+        public JdbcAsyncStreamReader(IAsyncStreamReader<T> reader)
+        {
+            _reader = reader;
+        }
+
+        public async Task<bool> MoveNext(CancellationToken cancellationToken)
+        {
+            try
+            {
+                return await _reader.MoveNext(cancellationToken);
+            }
+            catch (RpcException e)
+            {
+                throw new JdbcException(e);
+            }
+        }
+    }
+}
diff --git a/JDBC.NET.Data/JdbcCallInvoker.cs b/JDBC.NET.Data/JdbcCallInvoker.cs
deleted file mode 100644
index 000f189..0000000
--- a/JDBC.NET.Data/JdbcCallInvoker.cs
+++ /dev/null
@@ -1,175 +0,0 @@
-using System.Threading;
-using System.Threading.Tasks;
-using Grpc.Core;
-using JDBC.NET.Data.Exceptions;
-
-namespace JDBC.NET.Data
-{
-    internal sealed class JdbcCallInvoker : DefaultCallInvoker
-    {
-        public JdbcCallInvoker(Channel channel) : base(channel)
-        {
-        }
-
-        public override TResponse BlockingUnaryCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options, TRequest request)
-        {
-            try
-            {
-                return base.BlockingUnaryCall(method, host, options, request);
-            }
-            catch (RpcException e)
-            {
-                throw new JdbcException(e);
-            }
-        }
-
-        public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options, TRequest request)
-        {
-            AsyncUnaryCall<TResponse> asyncCall = base.AsyncUnaryCall(method, host, options, request);
-
-            return new AsyncUnaryCall<TResponse>(
-                Wrap(asyncCall.ResponseAsync),
-                Wrap(asyncCall.ResponseHeadersAsync),
-                asyncCall.GetStatus,
-                asyncCall.GetTrailers,
-                asyncCall.Dispose
-            );
-        }
-
-        public override AsyncClientStreamingCall<TRequest, TResponse> AsyncClientStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options)
-        {
-            AsyncClientStreamingCall<TRequest, TResponse> asyncCall = base.AsyncClientStreamingCall(method, host, options);
-
-            return new AsyncClientStreamingCall<TRequest, TResponse>(
-                Wrap(asyncCall.RequestStream),
-                Wrap(asyncCall.ResponseAsync),
-                Wrap(asyncCall.ResponseHeadersAsync),
-                asyncCall.GetStatus,
-                asyncCall.GetTrailers,
-                asyncCall.Dispose
-            );
-        }
-
-        public override AsyncDuplexStreamingCall<TRequest, TResponse> AsyncDuplexStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options)
-        {
-            AsyncDuplexStreamingCall<TRequest, TResponse> asyncCall = base.AsyncDuplexStreamingCall(method, host, options);
-
-            return new AsyncDuplexStreamingCall<TRequest, TResponse>(
-                Wrap(asyncCall.RequestStream),
-                Wrap(asyncCall.ResponseStream),
-                Wrap(asyncCall.ResponseHeadersAsync),
-                asyncCall.GetStatus,
-                asyncCall.GetTrailers,
-                asyncCall.Dispose
-            );
-        }
-
-        public override AsyncServerStreamingCall<TResponse> AsyncServerStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options, TRequest request)
-        {
-            AsyncServerStreamingCall<TResponse> asyncCall = base.AsyncServerStreamingCall(method, host, options, request);
-
-            return new AsyncServerStreamingCall<TResponse>(
-                Wrap(asyncCall.ResponseStream),
-                Wrap(asyncCall.ResponseHeadersAsync),
-                asyncCall.GetStatus,
-                asyncCall.GetTrailers,
-                asyncCall.Dispose
-            );
-        }
-
-        private static async Task<T> Wrap<T>(Task<T> task)
-        {
-            if (task.Status != TaskStatus.WaitingForActivation)
-                return await task;
-
-            try
-            {
-                return await task;
-            }
-            catch (RpcException e)
-            {
-                throw new JdbcException(e);
-            }
-        }
-
-        private static IClientStreamWriter<T> Wrap<T>(IClientStreamWriter<T> writer)
-        {
-            if (writer == null)
-                return null;
-
-            return new JdbcClientStreamWriter<T>(writer);
-        }
-
-        private static IAsyncStreamReader<T> Wrap<T>(IAsyncStreamReader<T> reader)
-        {
-            if (reader == null)
-                return null;
-
-            return new JdbcAsyncStreamReader<T>(reader);
-        }
-
-        private readonly struct JdbcClientStreamWriter<T> : IClientStreamWriter<T>
-        {
-            public WriteOptions WriteOptions
-            {
-                get => _writer.WriteOptions;
-                set => _writer.WriteOptions = value;
-            }
-
-            private readonly IClientStreamWriter<T> _writer;
-
-            public JdbcClientStreamWriter(IClientStreamWriter<T> writer)
-            {
-                _writer = writer;
-            }
-
-            public async Task WriteAsync(T message)
-            {
-                try
-                {
-                    await _writer.WriteAsync(message);
-                }
-                catch (RpcException e)
-                {
-                    throw new JdbcException(e);
-                }
-            }
-
-            public async Task CompleteAsync()
-            {
-                try
-                {
-                    await _writer.CompleteAsync();
-                }
-                catch (RpcException e)
-                {
-                    throw new JdbcException(e);
-                }
-            }
-        }
-
-        private readonly struct JdbcAsyncStreamReader<T> : IAsyncStreamReader<T>
-        {
-            public T Current => _reader.Current;
-
-            private readonly IAsyncStreamReader<T> _reader;
-
-            public JdbcAsyncStreamReader(IAsyncStreamReader<T> reader)
-            {
-                _reader = reader;
-            }
-
-            public async Task<bool> MoveNext(CancellationToken cancellationToken)
-            {
-                try
-                {
-                    return await _reader.MoveNext(cancellationToken);
-                }
-                catch (RpcException e)
-                {
-                    throw new JdbcException(e);
-                }
-            }
-        }
-    }
-}
diff --git a/JDBC.NET.Data/JdbcChannel.cs b/JDBC.NET.Data/JdbcChannel.cs
deleted file mode 100644
index c6d89fd..0000000
--- a/JDBC.NET.Data/JdbcChannel.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using System.Collections.Generic;
-using Grpc.Core;
-
-namespace JDBC.NET.Data
-{
-    internal sealed class JdbcChannel : Channel
-    {
-        public JdbcChannel(string target, ChannelCredentials credentials) : base(target, credentials)
-        {
-        }
-
-        public JdbcChannel(string target, ChannelCredentials credentials, IEnumerable<ChannelOption> options) : base(target, credentials, options)
-        {
-        }
-
-        public JdbcChannel(string host, int port, ChannelCredentials credentials) : base(host, port, credentials)
-        {
-        }
-
-        public JdbcChannel(string host, int port, ChannelCredentials credentials, IEnumerable<ChannelOption> options) : base(host, port, credentials, options)
-        {
-        }
-
-        public override CallInvoker CreateCallInvoker()
-        {
-            return new JdbcCallInvoker(this);
-        }
-    }
-}
diff --git a/JDBC.NET.Data/Models/JdbcBridge.cs b/JDBC.NET.Data/Models/JdbcBridge.cs
index 845790e..6946563 100644
--- a/JDBC.NET.Data/Models/JdbcBridge.cs
+++ b/JDBC.NET.Data/Models/JdbcBridge.cs
@@ -6,7 +6,8 @@
 using System.Reflection;
 using System.Runtime.InteropServices;
 using System.Threading;
-using Grpc.Core;
+using Grpc.Core.Interceptors;
+using Grpc.Net.Client;
 using J2NET;
 using JDBC.NET.Proto;
 
@@ -15,7 +16,7 @@ namespace JDBC.NET.Data.Models
     internal sealed class JdbcBridge : IDisposable
     {
         #region Fields
-        private Channel _channel;
+        private GrpcChannel _channel;
         private Process _process;
         #endregion
 
@@ -109,14 +110,21 @@ private void Initialize()
             {
                 var port = bridgePort.GetPort();
 
-                var channel = new JdbcChannel(host, port, ChannelCredentials.Insecure);
-                channel.ConnectAsync().Wait(CancellationToken.None);
-
-                Driver = new DriverService.DriverServiceClient(channel);
-                Reader = new ReaderService.ReaderServiceClient(channel);
-                Statement = new StatementService.StatementServiceClient(channel);
-                Database = new DatabaseService.DatabaseServiceClient(channel);
-                MetaData = new MetaDataService.MetaDataServiceClient(channel);
+                var options = new GrpcChannelOptions
+                {
+                    MaxReceiveMessageSize = null,
+                    MaxSendMessageSize = null,
+                    DisposeHttpClient = true,
+                };
+
+                var channel = GrpcChannel.ForAddress($"http://{host}:{port}", options);
+                var channelWithInterceptor = channel.Intercept(new JdbcCallInterceptor());
+
+                Driver = new DriverService.DriverServiceClient(channelWithInterceptor);
+                Reader = new ReaderService.ReaderServiceClient(channelWithInterceptor);
+                Statement = new StatementService.StatementServiceClient(channelWithInterceptor);
+                Database = new DatabaseService.DatabaseServiceClient(channelWithInterceptor);
+                MetaData = new MetaDataService.MetaDataServiceClient(channelWithInterceptor);
 
                 var loadDriverResponse = Driver.loadDriver(
                     new LoadDriverRequest