diff --git a/src/calls.rs b/src/calls.rs
index 2c0402fbc0..ab53bd71ce 100644
--- a/src/calls.rs
+++ b/src/calls.rs
@@ -660,9 +660,21 @@ pub(crate) async fn create_fallback_ice_servers(context: &Context) -> Result<Str
     // because of bandwidth costs:
     // <https://github.com/jselbie/stunserver/issues/50>
 
-    // We use nine.testrun.org for a default STUN server.
-    let hostname = "nine.testrun.org";
+    let hostname = "turn.delta.chat";
+    // Do not use cache because there is no TLS.
+    let load_cache = false;
+    let urls: Vec<String> = lookup_host_with_cache(context, hostname, STUN_PORT, "", load_cache)
+        .await?
+        .into_iter()
+        .map(|addr| format!("turn:{addr}"))
+        .collect();
+    let turn_server = IceServer {
+        urls,
+        username: Some("public".to_string()),
+        credential: Some("o4tR7yG4rG2slhXqRUf9zgmHz".to_string()),
+    };
 
+    let hostname = "nine.testrun.org";
     // Do not use cache because there is no TLS.
     let load_cache = false;
     let urls: Vec<String> = lookup_host_with_cache(context, hostname, STUN_PORT, "", load_cache)
@@ -670,14 +682,13 @@ pub(crate) async fn create_fallback_ice_servers(context: &Context) -> Result<Str
         .into_iter()
         .map(|addr| format!("stun:{addr}"))
         .collect();
-
-    let ice_server = IceServer {
+    let stun_server = IceServer {
         urls,
         username: None,
         credential: None,
     };
 
-    let json = serde_json::to_string(&[ice_server])?;
+    let json = serde_json::to_string(&[turn_server, stun_server])?;
     Ok(json)
 }
 
diff --git a/src/imap.rs b/src/imap.rs
index e9ccc95f21..09c1825be2 100644
--- a/src/imap.rs
+++ b/src/imap.rs
@@ -123,7 +123,7 @@ struct OAuth2 {
     access_token: String,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub(crate) struct ServerMetadata {
     /// IMAP METADATA `/shared/comment` as defined in
     /// <https://www.rfc-editor.org/rfc/rfc5464#section-6.2.1>.
@@ -1546,17 +1546,17 @@ impl Session {
         Ok(())
     }
 
-    /// Retrieves server metadata if it is supported.
+    /// Retrieves server metadata if it is supported, otherwise uses fallback one.
     ///
     /// We get [`/shared/comment`](https://www.rfc-editor.org/rfc/rfc5464#section-6.2.1)
     /// and [`/shared/admin`](https://www.rfc-editor.org/rfc/rfc5464#section-6.2.2)
     /// metadata.
-    pub(crate) async fn fetch_metadata(&mut self, context: &Context) -> Result<()> {
+    pub(crate) async fn update_metadata(&mut self, context: &Context) -> Result<()> {
+        let mut lock = context.metadata.write().await;
+
         if !self.can_metadata() {
-            return Ok(());
+            *lock = Some(Default::default());
         }
-
-        let mut lock = context.metadata.write().await;
         if let Some(ref mut old_metadata) = *lock {
             let now = time();
 
@@ -1565,31 +1565,33 @@ impl Session {
                 return Ok(());
             }
 
-            info!(context, "ICE servers expired, requesting new credentials.");
-            let mailbox = "";
-            let options = "";
-            let metadata = self
-                .get_metadata(mailbox, options, "(/shared/vendor/deltachat/turn)")
-                .await?;
             let mut got_turn_server = false;
-            for m in metadata {
-                if m.entry == "/shared/vendor/deltachat/turn"
-                    && let Some(value) = m.value
-                {
-                    match create_ice_servers_from_metadata(context, &value).await {
-                        Ok((parsed_timestamp, parsed_ice_servers)) => {
-                            old_metadata.ice_servers_expiration_timestamp = parsed_timestamp;
-                            old_metadata.ice_servers = parsed_ice_servers;
-                            got_turn_server = false;
-                        }
-                        Err(err) => {
-                            warn!(context, "Failed to parse TURN server metadata: {err:#}.");
+            if self.can_metadata() {
+                info!(context, "ICE servers expired, requesting new credentials.");
+                let mailbox = "";
+                let options = "";
+                let metadata = self
+                    .get_metadata(mailbox, options, "(/shared/vendor/deltachat/turn)")
+                    .await?;
+                for m in metadata {
+                    if m.entry == "/shared/vendor/deltachat/turn"
+                        && let Some(value) = m.value
+                    {
+                        match create_ice_servers_from_metadata(context, &value).await {
+                            Ok((parsed_timestamp, parsed_ice_servers)) => {
+                                old_metadata.ice_servers_expiration_timestamp = parsed_timestamp;
+                                old_metadata.ice_servers = parsed_ice_servers;
+                                got_turn_server = true;
+                            }
+                            Err(err) => {
+                                warn!(context, "Failed to parse TURN server metadata: {err:#}.");
+                            }
                         }
                     }
                 }
             }
-
             if !got_turn_server {
+                info!(context, "Will use fallback ICE servers.");
                 // Set expiration timestamp 7 days in the future so we don't request it again.
                 old_metadata.ice_servers_expiration_timestamp = time() + 3600 * 24 * 7;
                 old_metadata.ice_servers = create_fallback_ice_servers(context).await?;
diff --git a/src/scheduler.rs b/src/scheduler.rs
index ab809c987d..5bea9211af 100644
--- a/src/scheduler.rs
+++ b/src/scheduler.rs
@@ -536,9 +536,9 @@ async fn inbox_fetch_idle(ctx: &Context, imap: &mut Imap, mut session: Session)
         .await
         .context("Failed to download messages")?;
     session
-        .fetch_metadata(ctx)
+        .update_metadata(ctx)
         .await
-        .context("Failed to fetch metadata")?;
+        .context("update_metadata")?;
     session
         .register_token(ctx)
         .await