@@ -9,6 +9,7 @@
 import warnings
 from copy import deepcopy
 from enum import Enum
+from time import sleep
 from typing import Any, Dict, List, Optional, Type, Union, overload
 from uuid import UUID, uuid4
 from warnings import warn
@@ -1643,8 +1644,10 @@ class StoreEntityParam(OswBaseModel):
         """If set to True, the existence of every edited page is queried after the
         upload. A page that does not exist afterwards is reported in
         StoreEntityResult.failed instead of StoreEntityResult.pages. This costs one
-        additional API request per 50 edited pages. Has no effect if 'offline' is
-        True."""
+        additional API request per 50 edited pages, and one further request some
+        seconds later if a page is reported as missing. If the query itself fails,
+        the pages are reported as stored and an error is logged. Has no effect if
+        'offline' is True."""
         _overwrite_per_class: Dict[str, Dict[str, OSW.OverwriteClassParam]] = (
             PrivateAttr()
         )
@@ -1739,9 +1742,32 @@ def __init__(self, title: str):
                 f"rejected by the wiki without an error response."
             )
 
-    def _get_missing_page_titles(self, titles: List[str]) -> List[str]:
+    def _get_missing_page_titles(
+        self, titles: List[str], confirm_delay_s: int = 5
+    ) -> List[str]:
         """Returns those of the given page titles that do not exist on the wiki.
 
+        A title the wiki reports as missing is queried a second time after
+        confirm_delay_s seconds. A read can be answered by a database replica that
+        does not have the write yet, and a title that is still absent seconds later
+        is not explained by that lag.
+
+        Parameters
+        ----------
+        titles:
+            Full page titles to check.
+        confirm_delay_s:
+            Seconds to wait before the second query. Set to 0 to query only once.
+        """
+        missing = self._query_missing_page_titles(titles)
+        if missing and confirm_delay_s:
+            sleep(confirm_delay_s)
+            missing = self._query_missing_page_titles(missing)
+        return missing
+
+    def _query_missing_page_titles(self, titles: List[str]) -> List[str]:
+        """Asks the wiki once which of the given page titles do not exist.
+
         The query goes to the MediaWiki API directly and not through
         WtSite.get_page(), because the page cache would answer with the state from
         before the write.
@@ -2032,7 +2058,18 @@ def failure_title_(upload_object: UploadObject) -> str:
             titles_to_verify = [
                 title for title in edited_titles if title in created_pages
             ]
-            for title in self._get_missing_page_titles(titles_to_verify):
+            try:
+                missing_titles = self._get_missing_page_titles(titles_to_verify)
+            except Exception as e:
+                # A failed query is no evidence that the writes failed. Report it
+                # and keep the pages, instead of discarding everything this call
+                # has collected so far.
+                missing_titles = []
+                _logger.error(
+                    f"Could not verify {len(titles_to_verify)} stored pages, they "
+                    f"are reported as stored without being checked: {e}"
+                )
+            for title in missing_titles:
                 error = OSW.PageNotCreatedError(title)
                 _logger.error(f"Error storing entity '{title}': {error}")
                 failed[title] = error
 
@@ -12,6 +12,7 @@
 
 import pytest
 
+import osw.core as core_mod
 import osw.model.entity as model
 from osw.core import OSW
 from osw.utils.wiki import get_namespace, get_title
@@ -23,21 +24,33 @@ def _title(entity):
 
 
 class _FakeMwSite:
-    """Records the API queries and answers them from a set of missing titles."""
+    """Records the API queries and answers them from a set of missing titles.
 
-    def __init__(self, missing_titles=(), normalized=None):
+    missing_once holds titles that are reported as missing by the first query
+    only, which is what a read from a lagging database replica looks like.
+    """
+
+    def __init__(
+        self, missing_titles=(), normalized=None, missing_once=(), fails=False
+    ):
         self.missing_titles = set(missing_titles)
+        self.missing_once = set(missing_once)
         self.normalized = normalized or {}
+        self.fails = fails
         self.queries = []
 
     def api(self, action, **kwargs):
         assert action == "query"
+        if self.fails:
+            raise RuntimeError("the API is not reachable")
         titles = kwargs["titles"].split("|")
         self.queries.append(titles)
+        missing_now = self.missing_titles | self.missing_once
+        self.missing_once = set()
         pages = {}
         for i, title in enumerate(titles):
             reported = self.normalized.get(title, title)
-            if title in self.missing_titles:
+            if title in missing_now:
                 pages[str(-(i + 1))] = {"title": reported, "missing": ""}
             else:
                 pages[str(i + 1)] = {"title": reported, "pageid": i + 1}
@@ -62,9 +75,11 @@ def offline_osw(monkeypatch):
         OSW, "_apply_overwrite_policy", staticmethod(lambda param: param.page)
     )
     monkeypatch.setattr(WtPage, "edit", lambda self, *a, **kw: None)
+    # the delay before the confirmation query, not worth waiting for in a test
+    monkeypatch.setattr(core_mod, "sleep", lambda *a, **kw: None)
 
-    def _make(missing_titles=(), normalized=None):
-        mw_site = _FakeMwSite(missing_titles, normalized)
+    def _make(missing_titles=(), normalized=None, missing_once=(), fails=False):
+        mw_site = _FakeMwSite(missing_titles, normalized, missing_once, fails)
         return OSW.construct(site=_FakeSite(mw_site)), mw_site
 
     return _make
@@ -137,6 +152,42 @@ def test_verification_is_skipped_offline(offline_osw):
     assert set(result.pages.keys()) == {title}
 
 
+def test_a_missing_page_is_confirmed_by_a_second_query(offline_osw):
+    item = model.Item(label=[model.Label(text="Ghost")])
+    title = _title(item)
+    osw_obj, mw_site = offline_osw(missing_titles=[title])
+
+    with pytest.raises(OSW.StoreEntityPartialError):
+        osw_obj.store_entity(OSW.StoreEntityParam(entities=[item], parallel=False))
+
+    assert mw_site.queries == [[title], [title]]
+
+
+def test_a_page_that_appears_on_the_second_query_is_not_reported(offline_osw):
+    """A read answered by a lagging database replica must not fail the store."""
+    items = [model.Item(label=[model.Label(text=f"Lag{i}")]) for i in range(2)]
+    titles = [_title(it) for it in items]
+    osw_obj, mw_site = offline_osw(missing_once=[titles[0]])
+
+    result = osw_obj.store_entity(OSW.StoreEntityParam(entities=items, parallel=False))
+
+    assert set(result.pages.keys()) == set(titles)
+    assert result.failed == {}
+    # the second query asks only for the title the first one reported as missing
+    assert mw_site.queries[1] == [titles[0]]
+
+
+def test_a_failing_query_keeps_the_pages_and_does_not_raise(offline_osw):
+    items = [model.Item(label=[model.Label(text=f"Unverified{i}")]) for i in range(2)]
+    titles = [_title(it) for it in items]
+    osw_obj, _mw_site = offline_osw(fails=True)
+
+    result = osw_obj.store_entity(OSW.StoreEntityParam(entities=items, parallel=False))
+
+    assert set(result.pages.keys()) == set(titles)
+    assert result.failed == {}
+
+
 def test_titles_are_queried_in_batches_of_fifty(offline_osw):
     osw_obj, mw_site = offline_osw()
     titles = [f"Item:OSW{i:04d}" for i in range(120)]