AuthRetryableFetchException + HandshakeException after app resumes from long background (Flutter, supabase_flutter ^2.10.3)

[vishal14321432]

After the app stays in the background for 6–8 hours or overnight, all Supabase requests fail with:

AuthRetryableFetchException(message: HandshakeException:
Connection terminated during handshake, statusCode: null)

This occurs even though everything works perfectly before the long background period — authentication, database reads/writes, storage, and realtime are all functioning normally.

Once this error occurs:

All Supabase operations fail (auth, postgrest, storage, realtime)

Realtime .onClose triggers but does not reconnect

The client does not recover even with retryable exceptions

Only a full app restart fixes the issue

The failure only occurs after the app resumes from a long idle state.

To Reproduce

1. Login to the app normally (works fine).
2. Use any Supabase functionality — all operations succeed.
3. Put the app in the background.
4. Leave it idle for 6+ hours (overnight).
5. Reopen the app in the morning.
6. Perform any Supabase operation (fetch, storage, realtime, etc.).
7. Observe this error:

AuthRetryableFetchException(message: HandshakeException:
Connection terminated during handshake)

The client does not reconnect or refresh without restarting the app.

Expected behavior

• When the app resumes after long inactivity:
• The Supabase client should refresh the session token (auto-refresh is enabled)
• TLS handshake should succeed
• Realtime should reconnect

PostgREST, Storage, and Auth requests should work normally

There should be no fatal handshake or retryable exceptions after resume.

Version

• Flutter SDK
• Flutter: 3.35.4 (stable)
• Dart: 3.9.2
• iOS: 18.6.2 (real devices)

├── supabase_flutter 2.10.3
│ ├── supabase 2.10.0
│ │ ├── functions_client 2.5.0
│ │ ├── gotrue 2.16.0
│ │ ├── postgrest 2.5.0
│ │ ├── realtime_client 2.6.0
│ │ ├── storage_client 2.4.1

supabase_flutter Initialization

await Supabase.initialize( url: dotenv.get('****'), anonKey: dotenv.get('****'), httpClient: SupabaseHttpInterceptor(http.Client()), realtimeClientOptions: RealtimeClientOptions( logLevel: RealtimeLogLevel.info, ), authOptions: const FlutterAuthClientOptions( autoRefreshToken: true, ), );

Additional context

• This occurs on multiple real iOS devices (iPhone 11 and others)
• Networking in the rest of the app works fine — only Supabase handshake fails
• Seems linked to long idle + TLS session resumption + auth refresh
• Realtime .onClose prints after resume
• Reconnection attempts fail silently
• No permanent fix except restarting the app

Sentry Log (redacted)

AuthRetryableFetchException(message: HandshakeException:

• Connection terminated during handshake, statusCode: null)
• Device: iPhone 11
• iOS: 18.6.2
• Architecture: arm64
• Flutter: 3.35.4
• Dart: 3.9.2
• supabase_flutter: ^2.10.3
• Environment: production

Simple Visual Explanation

App Running → Background (6–8 hrs) → Resume App
↓
Supabase tries handshake + token refresh
↓
❌ HandshakeException (TLS terminated)
❌ AuthRetryableFetchException
❌ Realtime disconnects & does not reconnect
❌ All PostgREST/Storage/Auth calls fail
↓
Only fix = restart app

[Vinzent03]

This is a http connection issue, which not directly depends on this package. What is your SupabaseHttpInterceptor? Can you make http request to services other than supabase?

[vishal14321432]

Here is the SupabaseHttpInterceptor class and Normal HTTP works Only Supabase HTTP/TLS handshake fails

`import 'dart:io';
import 'package:flutter/foundation.dart';
import 'package:http/http.dart' as http;
import 'package:http/http.dart';
import 'package:supabase_flutter/supabase_flutter.dart';

class SupabaseHttpInterceptor extends http.BaseClient {
final http.Client _inner;
bool _repairing = false;

SupabaseHttpInterceptor(this._inner);

@OverRide
Future send(BaseRequest request) async {
try {
return await _inner.send(request);
} catch (e) {
final shouldRetry = _shouldRetry(e);
if (!shouldRetry) rethrow;

  await _repair();

  final newReq = await _copyRequest(request);
  return await _inner.send(newReq);

}

}

bool _shouldRetry(Object e) {
final msg = e.toString();

bool result = msg.contains("HandshakeException") ||
    msg.contains("AuthRetryableFetchException") ||
    msg.contains("CERT") ||
    msg.contains("certificate") ||
    msg.contains("Connection closed") ||
    msg.contains("CERTIFICATE_VERIFY_FAILED") ||
    msg.contains("Chain validation failed") ||
    msg.contains("NetworkError") ||
    e is SocketException;
return result;

}

Future _repair() async {
if (_repairing) return;
_repairing = true;

final supabase = Supabase.instance.client;

try {
  await supabase.auth.refreshSession();
} catch (e, s) {
  if (kDebugMode) print('refreshSession()-----$e $s');
}

try {
  supabase.realtime .disconnect();
} catch (e, s) {
  if (kDebugMode) print('disconnect()-----$e $s');
}

await Future.delayed(const Duration(milliseconds: 200));

try {
  supabase.realtime.reconnectTimer.scheduleTimeout();
} catch (e, s) {
  if (kDebugMode) print('scheduleTimeout()-----$e $s');
}

_repairing = false;

}

Future _copyRequest(BaseRequest request) async {
final newRequest = Request(request.method, request.url);

newRequest.headers.addAll(request.headers);

if (request is Request) {
  newRequest.bodyBytes = request.bodyBytes;
} else {
  final body = await request.finalize().toBytes();
  newRequest.bodyBytes = body;
}

return newRequest;

}

}
`