diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 13ab29d5e..529c18086 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -148,7 +148,9 @@ jobs:
         with:
           repository: opendatateam/udata
           path: ${{ env.UDATA_WORKING_DIR }}
-          ref: main
+          # FIXME: geopf lives on this branch, not yet merged to main. Point back
+          # to `main` once the udata geopf PR (feat/geopf/init) merges.
+          ref: feat/geopf/init
 
       - name: Set up uv
         uses: astral-sh/setup-uv@v6
@@ -248,6 +250,7 @@ jobs:
           NUXT_SITE_URL: http://localhost:3000
           NUXT_PUBLIC_CHARTS_API_BASE: http://localhost:7000
           NUXT_PUBLIC_CADA_RESOURCE_ID: 3a6d6fe3-8548-43ed-ad09-72052771447c
+          NUXT_PUBLIC_GEOPF_ENABLED: "true"
         run: |
           # Start cdata server in background using pre-built artifacts
           PORT=3000 node .output/server/index.mjs > cdata.log 2>&1 &
diff --git a/components/Datasets/AdminDatasetResourcesPage.vue b/components/Datasets/AdminDatasetResourcesPage.vue
index 08fa3258d..6b5fffd51 100644
--- a/components/Datasets/AdminDatasetResourcesPage.vue
+++ b/components/Datasets/AdminDatasetResourcesPage.vue
@@ -78,7 +78,7 @@
       :schemas="schemas ?? []"
       :dataset
       @submit="updateResource"
-      @delete="refreshResources"
+      @delete="refreshAfterMutation"
     />
 
     <LoadingBlock
@@ -187,7 +187,7 @@
                 :loading
                 :resource="resourceToForm(resource, schemas ?? [])"
                 @submit="updateResource"
-                @delete="refreshResources"
+                @delete="refreshAfterMutation"
               />
             </td>
           </tr>
@@ -214,6 +214,7 @@ import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
 import UploadResourceModal from './UploadResourceModal.vue'
 import FileEditModal from './FileEditModal.vue'
 import FileEditModalFromQueryStringClient from './FileEditModalFromQueryString.client.vue'
+import { geopfEligibilityRefreshKey } from './geopfEligibilityRefreshKey'
 import type { AdminBadgeType, CommunityResourceForm, PaginatedArray, ResourceForm } from '~/types/types'
 
 const route = useRoute()
@@ -247,6 +248,14 @@ const refreshResources = async () => {
 }
 watchEffect(async () => await refreshResources())
 
+// Kept off `refreshResources`, which the watchEffect above also runs on every
+// pagination change.
+const refreshGeopfEligibility = inject(geopfEligibilityRefreshKey, () => {})
+const refreshAfterMutation = async () => {
+  await refreshResources()
+  refreshGeopfEligibility()
+}
+
 const { t } = useTranslation()
 
 const resourceForms = ref<Array<ResourceForm>>([])
@@ -271,7 +280,7 @@ const saveFirstNewFile = async (closeModal: () => void, form: ResourceForm | Com
   removeFirstNewFile()
 
   page.value = 1
-  refreshResources()
+  refreshAfterMutation()
 }
 const updateResource = async (closeModal: () => void, resourceForm: ResourceForm | CommunityResourceForm) => {
   if (!dataset.value) return
@@ -279,7 +288,7 @@ const updateResource = async (closeModal: () => void, resourceForm: ResourceForm
 
   try {
     await saveResourceForm(dataset.value, resourceForm)
-    await refreshResources()
+    await refreshAfterMutation()
     closeModal()
   }
   finally {
diff --git a/components/Datasets/FileEditModal.vue b/components/Datasets/FileEditModal.vue
index d239e0603..2065589eb 100644
--- a/components/Datasets/FileEditModal.vue
+++ b/components/Datasets/FileEditModal.vue
@@ -16,7 +16,8 @@
         :icon="RiPencilLine"
         :color="buttonColor"
         :size="buttonSize"
-        :title="$t('Éditer le fichier')"
+        :disabled="isSyncedWithGeopf"
+        :title="isSyncedWithGeopf ? $t('Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr') : $t('Éditer le fichier')"
         keep-margins-even-without-borders
         v-on="listeners"
       />
@@ -201,6 +202,7 @@ import DescribeResource from './DescribeResource.vue'
 import CdataLink from '../CdataLink.vue'
 import type { CommunityResourceForm, ResourceForm } from '~/types/types'
 import { useComponentsConfig } from '../../datagouv-components/src/config'
+import { isGeopfSynced } from '~/utils/geopf'
 
 const { t } = useTranslation()
 const { $api } = useNuxtApp()
@@ -232,6 +234,8 @@ const resourceForm = ref(cloneDeep(props.resource))
 const open = ref(false)
 const hasFileChanged = ref(false)
 
+const isSyncedWithGeopf = computed(() => props.resource.resource ? isGeopfSynced(props.resource.resource) : false)
+
 const hasTabularData = useHasTabularData()
 
 // Check if resource has tabular API
diff --git a/components/Datasets/GeopfDatastoreSelector.vue b/components/Datasets/GeopfDatastoreSelector.vue
new file mode 100644
index 000000000..51d8c694d
--- /dev/null
+++ b/components/Datasets/GeopfDatastoreSelector.vue
@@ -0,0 +1,55 @@
+<template>
+  <div v-if="pinnedDatastoreId">
+    <p class="text-sm text-gray-medium m-0">
+      {{ pinnedDatastoreName ? t('Entrepôt cartes.gouv.fr : {name} ({id})', { name: pinnedDatastoreName, id: pinnedDatastoreId }) : t('Entrepôt cartes.gouv.fr : {id}', { id: pinnedDatastoreId }) }}
+    </p>
+  </div>
+
+  <SelectGroup
+    v-else-if="connected === true"
+    v-model="localSelection"
+    :label="t('Entrepôt cartes.gouv.fr')"
+    :hint-text="t('Choisissez l\'entrepôt qui accueillera ce jeu de données sur cartes.gouv.fr. Ce choix ne pourra plus être modifié après le premier envoi.')"
+    :options="datastoreOptions"
+    class="max-w-sm"
+  />
+
+  <p
+    v-else
+    class="text-sm text-gray-medium m-0"
+  >
+    {{ t("Connectez-vous à cartes.gouv.fr pour choisir l'entrepôt de ce jeu de données.") }}
+  </p>
+</template>
+
+<script setup lang="ts">
+import { SelectGroup } from '@datagouv/components-next'
+import type { GeopfDatastore } from '~/utils/geopf'
+
+const props = defineProps<{
+  // Set on the dataset's first successful push, not editable afterwards.
+  pinnedDatastoreId: string | null
+  connected: boolean | null
+}>()
+
+const model = defineModel<string | null>({ default: null })
+
+const { t } = useTranslation()
+
+const { data: datastores } = props.connected === true
+  ? await useAPI<Array<GeopfDatastore>>('/api/1/geopf/datastores/')
+  : { data: ref(null) }
+
+const datastoreOptions = computed(() => (datastores.value ?? []).map(datastore => ({ label: datastore.name, value: datastore.datastore_id })))
+const pinnedDatastoreName = computed(() => (datastores.value ?? []).find(datastore => datastore.datastore_id === props.pinnedDatastoreId)?.name ?? null)
+
+const localSelection = ref<string | null>(null)
+
+watch(() => props.pinnedDatastoreId, (id) => {
+  if (id) model.value = id
+}, { immediate: true })
+
+watch(localSelection, (id) => {
+  if (!props.pinnedDatastoreId) model.value = id
+})
+</script>
diff --git a/components/Datasets/GeopfPanel.vue b/components/Datasets/GeopfPanel.vue
new file mode 100644
index 000000000..100020e04
--- /dev/null
+++ b/components/Datasets/GeopfPanel.vue
@@ -0,0 +1,84 @@
+<template>
+  <BannerAction
+    :type="bannerType"
+    :title="bannerTitle"
+  >
+    <template v-if="reauthRequired">
+      {{ t('Votre connexion a expiré ou a été révoquée.') }}
+    </template>
+    <template v-else-if="connected === false">
+      {{ t('Connectez-vous pour envoyer des fichiers et récupérer les services publiés sur cartes.gouv.fr.') }}
+    </template>
+    <template v-else-if="connected === true">
+      {{ t('Vous pouvez envoyer des fichiers vers cartes.gouv.fr depuis la liste ci-dessous.') }}
+    </template>
+
+    <template #button>
+      <a
+        v-if="connected !== true || reauthRequired"
+        class="fr-btn fr-btn--sm"
+        :href="geopfLoginUrl"
+      >
+        {{ t('Se connecter') }}
+      </a>
+      <BrandedButton
+        v-else
+        color="tertiary"
+        size="xs"
+        :icon="RiLogoutBoxLine"
+        :loading="disconnecting"
+        @click="disconnect"
+      >
+        {{ t('Se déconnecter') }}
+      </BrandedButton>
+    </template>
+  </BannerAction>
+</template>
+
+<script setup lang="ts">
+import { BannerAction, BrandedButton, toast } from '@datagouv/components-next'
+import { RiLogoutBoxLine } from '@remixicon/vue'
+
+const props = defineProps<{
+  // Id, not slug: /geopf/login/ only resolves by id.
+  datasetId: string
+  connected: boolean | null
+  reauthRequired?: boolean
+}>()
+
+const emit = defineEmits<{
+  disconnected: []
+}>()
+
+const { $api } = useNuxtApp()
+const { t } = useTranslation()
+const config = useRuntimeConfig()
+
+const geopfLoginUrl = computed(() => `${config.public.apiBase}/api/1/geopf/login/?dataset_id=${encodeURIComponent(props.datasetId)}`)
+
+const bannerType = computed(() => {
+  if (props.reauthRequired) return 'danger'
+  return props.connected === true ? 'primary' : 'warning'
+})
+const bannerTitle = computed(() => {
+  if (props.reauthRequired) return t('Reconnexion à cartes.gouv.fr requise')
+  return props.connected === true ? t('Connecté à cartes.gouv.fr') : t('Non connecté à cartes.gouv.fr')
+})
+
+const disconnecting = ref(false)
+
+const disconnect = async () => {
+  disconnecting.value = true
+  try {
+    await $api('/api/1/geopf/token/', { method: 'DELETE' })
+    toast.success(t('Vous êtes déconnecté de cartes.gouv.fr.'))
+    emit('disconnected')
+  }
+  catch {
+    // plugins/api.ts already toasted the error.
+  }
+  finally {
+    disconnecting.value = false
+  }
+}
+</script>
diff --git a/components/Datasets/GeopfPullButton.vue b/components/Datasets/GeopfPullButton.vue
new file mode 100644
index 000000000..2925c5f13
--- /dev/null
+++ b/components/Datasets/GeopfPullButton.vue
@@ -0,0 +1,81 @@
+<template>
+  <div class="flex flex-col items-end gap-1">
+    <component :is="disabledReason ? Tooltip : 'div'">
+      <BrandedButton
+        color="secondary"
+        size="xs"
+        :icon="RiDownloadCloud2Line"
+        :disabled="!!disabledReason"
+        :loading="pulling || pull.status === 'pending'"
+        @click="startPull"
+      >
+        {{ t('Récupérer les services') }}
+      </BrandedButton>
+
+      <template #tooltip>
+        {{ disabledReason }}
+      </template>
+    </component>
+
+    <span
+      v-if="pull.status === 'done' && pull.last_synced_at"
+      class="text-xs text-gray-medium"
+    >
+      {{ t('Dernière synchronisation : {date}', { date: formatDate(pull.last_synced_at) }) }}
+    </span>
+    <span
+      v-else-if="pull.status === 'error'"
+      class="text-xs text-new-error"
+    >
+      {{ pull.error }}
+    </span>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { BrandedButton, Tooltip, useFormatDate } from '@datagouv/components-next'
+import { RiDownloadCloud2Line } from '@remixicon/vue'
+import { isGeopfReauthRequired, type GeopfDatasetStatus } from '~/utils/geopf'
+
+const props = defineProps<{
+  datasetId: string
+  connected: boolean | null
+  pull: GeopfDatasetStatus['pull']
+  ficheUrl: string | null
+  refresh: () => Promise<void>
+}>()
+
+const emit = defineEmits<{
+  reauthRequired: []
+}>()
+
+const { $api } = useNuxtApp()
+const { t } = useTranslation()
+const { formatDate } = useFormatDate()
+
+const disabledReason = computed(() => {
+  if (props.connected !== true) return t('Connectez-vous à cartes.gouv.fr pour récupérer les services.')
+  if (!props.ficheUrl) return t('Envoyez d\'abord un fichier éligible vers cartes.gouv.fr.')
+  return null
+})
+
+const pulling = ref(false)
+
+const startPull = async () => {
+  pulling.value = true
+  try {
+    await $api(`/api/1/geopf/pull-offerings/${props.datasetId}/`, { method: 'POST' })
+    // Awaited: udata marks the dataset `pending` before enqueueing, so this returns the new status.
+    await props.refresh()
+  }
+  catch (error) {
+    if (isGeopfReauthRequired(error)) {
+      emit('reauthRequired')
+    }
+    // Otherwise plugins/api.ts already toasted the error.
+  }
+  finally {
+    pulling.value = false
+  }
+}
+</script>
diff --git a/components/Datasets/GeopfPushStatus.vue b/components/Datasets/GeopfPushStatus.vue
new file mode 100644
index 000000000..871f567e2
--- /dev/null
+++ b/components/Datasets/GeopfPushStatus.vue
@@ -0,0 +1,129 @@
+<template>
+  <component
+    :is="disabledReason ? Tooltip : 'div'"
+    v-if="push.status === null"
+  >
+    <BrandedButton
+      color="secondary"
+      size="xs"
+      :icon="RiUploadCloud2Line"
+      :disabled="!!disabledReason"
+      :loading="pushing"
+      @click="startPush"
+    >
+      {{ t('Envoyer vers cartes.gouv.fr') }}
+    </BrandedButton>
+
+    <template #tooltip>
+      {{ disabledReason }}
+    </template>
+  </component>
+
+  <AdminBadge
+    v-else-if="push.status === 'pending'"
+    size="xs"
+    type="primary"
+  >
+    {{ t('Envoi en cours…') }}
+  </AdminBadge>
+
+  <div
+    v-else-if="push.status === 'done'"
+    class="flex flex-col items-start"
+  >
+    <AdminBadge
+      size="xs"
+      type="success"
+    >
+      {{ t('Synchronisé') }}
+    </AdminBadge>
+    <span
+      v-if="push.last_synced_at"
+      class="text-xs text-gray-medium"
+    >
+      {{ formatDate(push.last_synced_at) }}
+    </span>
+  </div>
+
+  <div
+    v-else
+    class="flex flex-col items-start gap-1"
+  >
+    <Tooltip>
+      <AdminBadge
+        size="xs"
+        type="danger"
+      >
+        {{ push.status === 'timeout' ? t('Délai dépassé') : t("Échec de l'envoi") }}
+      </AdminBadge>
+
+      <template #tooltip>
+        {{ push.error }}
+      </template>
+    </Tooltip>
+
+    <BrandedButton
+      color="tertiary"
+      size="xs"
+      :icon="RiRefreshLine"
+      :disabled="!!disabledReason"
+      :loading="pushing"
+      @click="startPush"
+    >
+      {{ t('Réessayer') }}
+    </BrandedButton>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { BrandedButton, Tooltip, useFormatDate } from '@datagouv/components-next'
+import { RiRefreshLine, RiUploadCloud2Line } from '@remixicon/vue'
+import { isGeopfReauthRequired, type GeopfPushableResource } from '~/utils/geopf'
+
+const props = defineProps<{
+  resource: GeopfPushableResource
+  datasetId: string
+  connected: boolean | null
+  datastoreId: string | null
+  refresh: () => Promise<void>
+}>()
+
+const emit = defineEmits<{
+  reauthRequired: []
+}>()
+
+const { $api } = useNuxtApp()
+const { t } = useTranslation()
+const { formatDate } = useFormatDate()
+
+const push = computed(() => props.resource.push)
+
+const disabledReason = computed(() => {
+  if (props.connected !== true) return t('Connectez-vous à cartes.gouv.fr pour envoyer ce fichier.')
+  if (!props.datastoreId) return t('Choisissez d\'abord l\'entrepôt cartes.gouv.fr de ce jeu de données.')
+  return null
+})
+
+const pushing = ref(false)
+
+const startPush = async () => {
+  pushing.value = true
+  try {
+    await $api(`/api/1/geopf/push/${props.datasetId}/${props.resource.id}/`, {
+      method: 'POST',
+      body: { datastore_id: props.datastoreId },
+    })
+    // Awaited: udata marks the resource `pending` before enqueueing, so this returns the new status
+    await props.refresh()
+  }
+  catch (error) {
+    if (isGeopfReauthRequired(error)) {
+      emit('reauthRequired')
+    }
+    // Otherwise plugins/api.ts already toasted the error.
+  }
+  finally {
+    pushing.value = false
+  }
+}
+</script>
diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
new file mode 100644
index 000000000..431c73ad1
--- /dev/null
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -0,0 +1,192 @@
+<template>
+  <div class="bg-white fr-p-3w">
+    <template v-if="canEdit">
+      <GeopfPanel
+        :dataset-id="dataset.id"
+        :connected="isGeopfConnected"
+        :reauth-required="reauthRequired"
+        class="fr-mb-3w"
+        @disconnected="onGeopfDisconnected"
+      />
+
+      <GeopfDatastoreSelector
+        v-model="datastoreId"
+        :pinned-datastore-id="geopfDatasetStatus?.push.datastore_id ?? null"
+        :connected="isGeopfConnected"
+        class="fr-mb-3w"
+      />
+
+      <LoadingBlock
+        v-slot="{ data: loadedGeopfDatasetStatus }"
+        :status
+        :data="geopfDatasetStatus"
+      >
+        <h2 class="text-sm font-bold uppercase">
+          {{ t('Fichiers à envoyer') }}
+        </h2>
+        <AdminTable v-if="loadedGeopfDatasetStatus.pushable.length">
+          <thead>
+            <tr>
+              <AdminTableTh scope="col">
+                {{ t('Nom du fichier') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Format') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Envoi') }}
+              </AdminTableTh>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="resource in loadedGeopfDatasetStatus.pushable"
+              :key="resource.id"
+            >
+              <td>
+                <TextClamp
+                  :text="resource.title"
+                  :auto-resize="true"
+                  :max-lines="2"
+                />
+              </td>
+              <td>
+                {{ resource.format }}
+              </td>
+              <td>
+                <GeopfPushStatus
+                  :resource="resource"
+                  :dataset-id="datasetId"
+                  :connected="isGeopfConnected"
+                  :datastore-id="datastoreId"
+                  :refresh="refreshGeopfDatasetStatus"
+                  @reauth-required="reauthRequired = true"
+                />
+              </td>
+            </tr>
+          </tbody>
+        </AdminTable>
+        <p
+          v-else
+          class="text-sm text-gray-medium m-0"
+        >
+          {{ t("Aucun fichier éligible n'a été trouvé dans ce jeu de données.") }}
+        </p>
+
+        <div class="flex flex-wrap justify-between items-start gap-2 mt-8 mb-3">
+          <h2 class="text-sm font-bold uppercase m-0">
+            {{ t('Services récupérés depuis cartes.gouv.fr') }}
+          </h2>
+          <GeopfPullButton
+            :dataset-id="datasetId"
+            :connected="isGeopfConnected"
+            :pull="loadedGeopfDatasetStatus.pull"
+            :fiche-url="loadedGeopfDatasetStatus.push.fiche_url"
+            :refresh="refreshGeopfDatasetStatus"
+            @reauth-required="reauthRequired = true"
+          />
+        </div>
+        <AdminTable v-if="loadedGeopfDatasetStatus.offerings.length">
+          <thead>
+            <tr>
+              <AdminTableTh scope="col">
+                {{ t('Nom') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Format') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Dernière synchronisation') }}
+              </AdminTableTh>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="resource in loadedGeopfDatasetStatus.offerings"
+              :key="resource.id"
+            >
+              <td>
+                <TextClamp
+                  :text="resource.title"
+                  :auto-resize="true"
+                  :max-lines="2"
+                />
+              </td>
+              <td>
+                {{ resource.format }}
+              </td>
+              <td>
+                {{ formatDate(resource.offering.last_synced_at) }}
+              </td>
+            </tr>
+          </tbody>
+        </AdminTable>
+        <p
+          v-else
+          class="text-sm text-gray-medium m-0"
+        >
+          {{ t("Aucun service n'a encore été synchronisé depuis cartes.gouv.fr.") }}
+        </p>
+
+        <BrandedButton
+          v-if="loadedGeopfDatasetStatus.push.fiche_url"
+          color="secondary"
+          size="xs"
+          :href="loadedGeopfDatasetStatus.push.fiche_url"
+          new-tab
+          class="mt-3"
+        >
+          {{ t('Voir la fiche sur cartes.gouv.fr') }}
+        </BrandedButton>
+      </LoadingBlock>
+    </template>
+    <p
+      v-else
+      class="text-sm text-gray-medium m-0"
+    >
+      {{ t('Vous n\'avez pas la permission de synchroniser ce jeu de données avec cartes.gouv.fr.') }}
+    </p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { BrandedButton, LoadingBlock, useFormatDate, type DatasetV2 } from '@datagouv/components-next'
+import GeopfDatastoreSelector from './GeopfDatastoreSelector.vue'
+import GeopfPanel from './GeopfPanel.vue'
+import GeopfPullButton from './GeopfPullButton.vue'
+import GeopfPushStatus from './GeopfPushStatus.vue'
+import AdminTable from '../AdminTable/Table/AdminTable.vue'
+import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
+import { geopfDatasetStatusKey, geopfDatasetStatusUrl, type GeopfDatasetStatus } from '~/utils/geopf'
+
+const props = defineProps<{
+  dataset: DatasetV2
+}>()
+
+const route = useRoute()
+const { t } = useTranslation()
+const { formatDate } = useFormatDate()
+
+const datasetId = computed(() => String(route.params.id))
+
+const canEdit = computed(() => props.dataset.permissions.edit_resources)
+
+// Everything both tables render, already filtered and projected by udata.
+const { data: geopfDatasetStatus, status, refresh: refreshGeopfDatasetStatus } = await useAPI<GeopfDatasetStatus>(
+  computed(() => geopfDatasetStatusUrl(datasetId.value)),
+  { key: geopfDatasetStatusKey(datasetId.value) },
+)
+
+const { data: geopfConnected } = await useAPI<{ connected: boolean, expires_at: string | null }>('/api/1/geopf/status/')
+const isGeopfConnected = computed(() => geopfConnected.value?.connected ?? null)
+const reauthRequired = ref(false)
+const datastoreId = ref<string | null>(null)
+
+const geopfPending = computed(() => {
+  if (!geopfDatasetStatus.value) return false
+  return geopfDatasetStatus.value.pushable.some(r => r.push.status === 'pending') || geopfDatasetStatus.value.pull.status === 'pending'
+})
+useGeopfPolling(geopfPending, refreshGeopfDatasetStatus)
+
+const onGeopfDisconnected = () => reloadNuxtApp({ path: route.fullPath })
+</script>
diff --git a/components/Datasets/geopfEligibilityRefreshKey.ts b/components/Datasets/geopfEligibilityRefreshKey.ts
new file mode 100644
index 000000000..0511bd9c2
--- /dev/null
+++ b/components/Datasets/geopfEligibilityRefreshKey.ts
@@ -0,0 +1,7 @@
+import type { InjectionKey } from 'vue'
+
+// Lets the Files tab (which mutates resources) tell the admin dataset layout
+// (which decides whether the geopf tab is shown) to recheck eligibility, so a
+// newly-added resource surfaces the tab without a full page reload.
+export type GeopfEligibilityRefresh = () => void
+export const geopfEligibilityRefreshKey = Symbol() as InjectionKey<GeopfEligibilityRefresh>
diff --git a/components/SiteHeader/SiteHeader.vue b/components/SiteHeader/SiteHeader.vue
index 87334b0fb..a443f0de4 100644
--- a/components/SiteHeader/SiteHeader.vue
+++ b/components/SiteHeader/SiteHeader.vue
@@ -631,6 +631,9 @@ onMounted(() => {
     if (message) {
       toast[message.type](message.text)
     }
+
+    // Consume the flash: strip it from the URL so it can't resurface on a later reload.
+    router.replace({ query: { ...route.query, flash: undefined, info: undefined, error: undefined } })
   }
 })
 
diff --git a/composables/useGeopfPolling.ts b/composables/useGeopfPolling.ts
new file mode 100644
index 000000000..2e8f121d3
--- /dev/null
+++ b/composables/useGeopfPolling.ts
@@ -0,0 +1,12 @@
+import { useIntervalFn } from '@vueuse/core'
+import type { ComputedRef } from 'vue'
+
+const POLL_INTERVAL_MS = 8000
+
+// Polls for as long as a push or pull is pending. `useIntervalFn` pauses itself on
+// scope dispose.
+export function useGeopfPolling(pending: ComputedRef<boolean>, tick: () => Promise<void>) {
+  const { pause, resume } = useIntervalFn(tick, POLL_INTERVAL_MS, { immediate: false })
+
+  watch(pending, isPending => isPending ? resume() : pause(), { immediate: true })
+}
diff --git a/datagouv-components/src/components/ResourceAccordion/EditButton.vue b/datagouv-components/src/components/ResourceAccordion/EditButton.vue
index 4f8554255..b785d63a4 100644
--- a/datagouv-components/src/components/ResourceAccordion/EditButton.vue
+++ b/datagouv-components/src/components/ResourceAccordion/EditButton.vue
@@ -4,7 +4,8 @@
     icon-only
     :icon="RiPencilLine"
     color="warning"
-    :title="t('Éditer le fichier')"
+    :disabled="!!disabledReason"
+    :title="disabledReason ?? t('Éditer le fichier')"
     data-testid="edit-button"
   />
 </template>
@@ -19,10 +20,12 @@ type Props = {
   datasetId: string
   isCommunityResource?: boolean
   resourceId: string
+  disabledReason?: string | null
 }
 
 const props = withDefaults(defineProps<Props>(), {
   isCommunityResource: false,
+  disabledReason: null,
 })
 
 const { t } = useTranslation()
diff --git a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
index af35894a3..b922a28c3 100644
--- a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
+++ b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
@@ -173,6 +173,7 @@
             :dataset-id="dataset.id"
             :resource-id="resource.id"
             :is-community-resource="isCommunityResource"
+            :disabled-reason="editDisabledReason"
             size="xs"
           />
         </p>
@@ -327,7 +328,7 @@ import { trackEvent } from '../../functions/matomo'
 import CopyButton from '../CopyButton.vue'
 import { useComponentsConfig } from '../../config'
 import { getOwnerName } from '../../functions/owned'
-import { getResourceFormatIcon, getResourceTitleId, detectOgcService, getResourceExternalUrl, getResourceFilesize, isImagePreviewFormat } from '../../functions/resources'
+import { getResourceFormatIcon, getResourceTitleId, detectOgcService, getResourceExternalUrl, getResourceFilesize, isGeopfSynced, isImagePreviewFormat } from '../../functions/resources'
 import BrandedButton from '../BrandedButton.vue'
 import { useTranslation } from '../../composables/useTranslation'
 import { useHasTabularData } from '../../composables/useHasTabularData'
@@ -382,6 +383,10 @@ const hasPmtiles = computed(() => {
   return props.resource.extras['analysis:parsing:pmtiles_url'] || props.resource.format === 'pmtiles'
 })
 
+const editDisabledReason = computed(() => {
+  return isGeopfSynced(props.resource) ? t('Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr') : null
+})
+
 const hasDatafairPreview = computed(() => {
   // Checks if there are the corresponding extras for a datafair preview.
   // Limited only to datasets published by certified organizations since it will load an iframe.
diff --git a/datagouv-components/src/functions/resources.ts b/datagouv-components/src/functions/resources.ts
index 3e0b17c1e..b3f95f0b1 100644
--- a/datagouv-components/src/functions/resources.ts
+++ b/datagouv-components/src/functions/resources.ts
@@ -179,6 +179,10 @@ export function getResourceExternalUrl(dataset: Dataset | DatasetV2 | Omit<Datas
   return `${dataset.page}${isCommunityResource(resource) ? '/community-resources' : ''}?resource_id=${resource.id}`
 }
 
+export function isGeopfSynced(resource: Resource | CommunityResource): boolean {
+  return resource.geopf?.push_status != null || typeof resource.geopf?.offering_id === 'string'
+}
+
 export function getResourceFilesize(resource: Resource): null | number {
   if (resource.filesize) return resource.filesize
   if ('analysis:content-length' in resource.extras) return resource.extras['analysis:content-length'] as number
diff --git a/datagouv-components/src/types/resources.ts b/datagouv-components/src/types/resources.ts
index 2a1d9082d..f5d9ab02b 100644
--- a/datagouv-components/src/types/resources.ts
+++ b/datagouv-components/src/types/resources.ts
@@ -12,6 +12,11 @@ export type FileResourceFileType = 'file'
 
 export type ResourceFileType = RemoteResourceFileType | FileResourceFileType
 
+export type GeopfResourceMetadata = {
+  push_status?: 'pending' | 'done' | 'error' | 'timeout' | null
+  offering_id?: string | null
+}
+
 export type Resource = {
   id: string
   title: string
@@ -22,6 +27,7 @@ export type Resource = {
   extras: Record<string, unknown>
   metrics: { views: number }
   harvest: Harvest
+  geopf: GeopfResourceMetadata | null
   filesize: number | null
   filetype: ResourceFileType
   format: string
diff --git a/nuxt.config.ts b/nuxt.config.ts
index cc0a6ff23..58b7e532a 100644
--- a/nuxt.config.ts
+++ b/nuxt.config.ts
@@ -185,6 +185,8 @@ export default defineNuxtConfig({
       resourceFileUploadChunk: 20 * 1000 * 1000,
       maxSortableFiles: 50,
 
+      geopfEnabled: false,
+
       maxNumberOfDatasetsForDataserviceUpdate: 200,
 
       captcheta: {
diff --git a/pages/admin.vue b/pages/admin.vue
index 70e150617..11be0fc78 100644
--- a/pages/admin.vue
+++ b/pages/admin.vue
@@ -44,7 +44,7 @@
     </div>
     <div class="fr-col-12 fr-col-md-8 fr-col-lg-9 fr-col-xl-10 md:h-full !px-4 sm:!px-10 pb-8 md:pb-16 lg:pb-64">
       <NuxtPage
-        :page-key="route => route.fullPath"
+        :page-key="pageKey"
       />
     </div>
   </div>
@@ -54,6 +54,7 @@
 import { Disclosure, DisclosureButton, DisclosurePanel } from '@headlessui/vue'
 import AdminSidebarMenu from '~/components/AdminSidebar/AdminSidebarMenu/AdminSidebarMenu.vue'
 import type { OrganizationReference } from '@datagouv/components-next'
+import type { RouteLocationNormalizedLoaded } from 'vue-router'
 
 definePageMeta({
   layout: 'fluid',
@@ -78,6 +79,12 @@ useSeoMeta({ title: 'Admin' })
 
 const { organizations, users } = useCurrentOwned()
 const isSiteAdmin = computed(() => me.value.roles?.includes('admin') || false)
+
+// Stable reference: NuxtPage compares page-key by reference, so an inline function here
+// would re-trigger the loading indicator on every render of this component.
+function pageKey(route: RouteLocationNormalizedLoaded) {
+  return route.fullPath
+}
 </script>
 
 <style>
diff --git a/pages/admin/datasets/[id].vue b/pages/admin/datasets/[id].vue
index 08babde0b..2799326ca 100644
--- a/pages/admin/datasets/[id].vue
+++ b/pages/admin/datasets/[id].vue
@@ -125,11 +125,12 @@
           { href: `${getDatasetAdminUrl(dataset)}/files`, label: t('Fichiers') },
           { href: `${getDatasetAdminUrl(dataset)}/discussions`, label: t('Discussions') },
           { href: `${getDatasetAdminUrl(dataset)}/activities`, label: t('Activités'), show: dataset.permissions.edit },
+          { href: `${getDatasetAdminUrl(dataset)}/geopf`, label: t('Synchronisation cartes.gouv.fr'), show: config.public.geopfEnabled && dataset.permissions.edit_resources && hasEligibleGeopfResource },
         ]"
       />
 
       <NuxtPage
-        :page-key="route => route.fullPath"
+        :page-key="pageKey"
         :dataset
       />
     </div>
@@ -144,7 +145,10 @@ import DatasetBadge from '~/components/AdminBadge/DatasetBadge.vue'
 import AdminBreadcrumb from '~/components/Breadcrumbs/AdminBreadcrumb.vue'
 import BreadcrumbItem from '~/components/Breadcrumbs/BreadcrumbItem.vue'
 import TabLinks from '~/components/TabLinks.vue'
+import { geopfEligibilityRefreshKey } from '~/components/Datasets/geopfEligibilityRefreshKey'
 import type { PaginatedArray } from '~/types/types'
+import { geopfDatasetStatusKey, geopfDatasetStatusUrl, type GeopfDatasetStatus } from '~/utils/geopf'
+import type { RouteLocationNormalizedLoaded } from 'vue-router'
 
 definePageMeta({
   keepScroll: true,
@@ -152,6 +156,7 @@ definePageMeta({
 
 const { t } = useTranslation()
 const me = useMe()
+const config = useRuntimeConfig()
 
 const route = useRoute()
 const url = computed(() => `/api/2/datasets/${route.params.id}/`)
@@ -167,4 +172,24 @@ const { data: activities } = await useAPI<PaginatedArray<Activity>>('/api/1/acti
     sort: '-created_at',
   },
 })
+
+// Drives the geopf tab's visibility. Shares its useAsyncData key with GeopfSyncPage.
+const canFetchGeopfStatus = Boolean(config.public.geopfEnabled && dataset.value?.permissions.edit_resources)
+const { data: geopfDatasetStatus, refresh: refreshGeopfDatasetStatus } = canFetchGeopfStatus
+  ? await useAPI<GeopfDatasetStatus>(
+      computed(() => geopfDatasetStatusUrl(String(route.params.id))),
+      { key: geopfDatasetStatusKey(String(route.params.id)) },
+    )
+  : { data: ref(null), refresh: async () => {} }
+const hasEligibleGeopfResource = computed(() => Boolean(geopfDatasetStatus.value && (geopfDatasetStatus.value.pushable.length || geopfDatasetStatus.value.offerings.length)))
+
+// The Files tab calls this after any resource change, so a newly-uploaded eligibile
+// resource makes the tab appear without a full page reload.
+provide(geopfEligibilityRefreshKey, () => refreshGeopfDatasetStatus())
+
+// Stable reference: NuxtPage compares page-key by reference, so an inline function for pageKey
+// would re-trigger the loading indicator whenever `dataset` changes and this re-renders.
+function pageKey(route: RouteLocationNormalizedLoaded) {
+  return route.fullPath
+}
 </script>
diff --git a/pages/admin/datasets/[id]/geopf.vue b/pages/admin/datasets/[id]/geopf.vue
new file mode 100644
index 000000000..0fdcb7143
--- /dev/null
+++ b/pages/admin/datasets/[id]/geopf.vue
@@ -0,0 +1,21 @@
+<template>
+  <GeopfSyncPage
+    v-if="config.public.geopfEnabled"
+    :dataset="dataset"
+  />
+</template>
+
+<script setup lang="ts">
+import type { DatasetV2 } from '@datagouv/components-next'
+import GeopfSyncPage from '~/components/Datasets/GeopfSyncPage.vue'
+
+defineProps<{
+  dataset: DatasetV2
+}>()
+
+const config = useRuntimeConfig()
+
+if (!config.public.geopfEnabled) {
+  showError({ statusCode: 404, statusMessage: 'Page Not Found' })
+}
+</script>
diff --git a/plugins/api.ts b/plugins/api.ts
index bfa926d0d..4a89381fc 100644
--- a/plugins/api.ts
+++ b/plugins/api.ts
@@ -36,7 +36,7 @@ export default defineNuxtPlugin({
             options.query['lang'] = locale
           }
         },
-        async onResponseError({ response, options }) {
+        async onResponseError({ request, response, options }) {
           if (response.status === 404) {
             if (apiOptions.redirectOn404) {
               await nuxtApp.runWithContext(() => showError({ statusCode: 404, statusMessage: 'Page Not Found' }))
@@ -60,6 +60,11 @@ export default defineNuxtPlugin({
             }
           }
 
+          if (response.status === 424 && typeof request === 'string' && request.includes('/geopf/')) {
+            // Means "not connected": callers handle this themselves (prompt to reconnect).
+            return
+          }
+
           if (response.status === 429) {
             toast.error(t('Erreur API 429 : trop de requêtes. Veuillez réessayer plus tard.'))
             return
diff --git a/tests-unit/datagouv-components/resources.spec.ts b/tests-unit/datagouv-components/resources.spec.ts
index b718cc4a2..802fc1924 100644
--- a/tests-unit/datagouv-components/resources.spec.ts
+++ b/tests-unit/datagouv-components/resources.spec.ts
@@ -1,7 +1,7 @@
 import { createApp } from 'vue'
 import { describe, expect, it } from 'vitest'
 import { configKey, type ResolvedPluginConfig } from '~/datagouv-components/src/config'
-import { detectOgcService, getResourceCorsStatus, isCommunityResource } from '~/datagouv-components/src/functions/resources'
+import { detectOgcService, getResourceCorsStatus, isCommunityResource, isGeopfSynced } from '~/datagouv-components/src/functions/resources'
 import type { CommunityResource, Resource } from '~/datagouv-components/src/types/resources'
 
 // `useComponentsConfig` relies on Vue's inject: run the function inside an app
@@ -70,3 +70,24 @@ describe('isCommunityResource', () => {
     expect(isCommunityResource({ id: 'res-1' } as unknown as Resource)).toBe(false)
   })
 })
+
+describe('isGeopfSynced', () => {
+  it('is false without any geopf metadata', () => {
+    expect(isGeopfSynced({ geopf: null } as Resource)).toBe(false)
+  })
+
+  it('is true once any push has been attempted, whatever its outcome', () => {
+    expect(isGeopfSynced({ geopf: { push_status: 'pending' } } as Resource)).toBe(true)
+    expect(isGeopfSynced({ geopf: { push_status: 'done' } } as Resource)).toBe(true)
+    expect(isGeopfSynced({ geopf: { push_status: 'error' } } as Resource)).toBe(true)
+    expect(isGeopfSynced({ geopf: { push_status: 'timeout' } } as Resource)).toBe(true)
+  })
+
+  it('is true for a resource pulled back as an offering', () => {
+    expect(isGeopfSynced({ geopf: { offering_id: 'offering-1' } } as Resource)).toBe(true)
+  })
+
+  it('ignores a non-string offering id', () => {
+    expect(isGeopfSynced({ geopf: { offering_id: 42 as unknown as string } } as Resource)).toBe(false)
+  })
+})
diff --git a/tests-unit/utils/geopf.spec.ts b/tests-unit/utils/geopf.spec.ts
new file mode 100644
index 000000000..b57c81e65
--- /dev/null
+++ b/tests-unit/utils/geopf.spec.ts
@@ -0,0 +1,37 @@
+import { describe, expect, it } from 'vitest'
+import { geopfDatasetStatusKey, geopfDatasetStatusUrl, isGeopfReauthRequired } from '~/utils/geopf'
+
+describe('geopfDatasetStatusUrl', () => {
+  it('builds the per-dataset status route', () => {
+    expect(geopfDatasetStatusUrl('abc123')).toBe('/api/1/geopf/status/abc123/')
+  })
+})
+
+describe('geopfDatasetStatusKey', () => {
+  it('builds a key stable for a given dataset id', () => {
+    expect(geopfDatasetStatusKey('abc123')).toBe('geopf-status-abc123')
+    expect(geopfDatasetStatusKey('abc123')).toBe(geopfDatasetStatusKey('abc123'))
+  })
+
+  it('differs across dataset ids', () => {
+    expect(geopfDatasetStatusKey('abc123')).not.toBe(geopfDatasetStatusKey('def456'))
+  })
+})
+
+describe('isGeopfReauthRequired', () => {
+  it('is false for non-object or response-less errors', () => {
+    expect(isGeopfReauthRequired(null)).toBe(false)
+    expect(isGeopfReauthRequired(undefined)).toBe(false)
+    expect(isGeopfReauthRequired('nope')).toBe(false)
+    expect(isGeopfReauthRequired(new Error('boom'))).toBe(false)
+  })
+
+  it('is false for a response with another status', () => {
+    expect(isGeopfReauthRequired({ response: { status: 500 } })).toBe(false)
+    expect(isGeopfReauthRequired({ response: {} })).toBe(false)
+  })
+
+  it('is true only for a 424 response', () => {
+    expect(isGeopfReauthRequired({ response: { status: 424 } })).toBe(true)
+  })
+})
diff --git a/tests/datasets/geopf.spec.ts b/tests/datasets/geopf.spec.ts
new file mode 100644
index 000000000..8c192a54f
--- /dev/null
+++ b/tests/datasets/geopf.spec.ts
@@ -0,0 +1,96 @@
+import { test, expect } from '../base'
+import { API_BASE, createDataset, createRemoteResource, deleteDatasets } from '../helpers'
+
+const createdDatasets: Array<string> = []
+
+test.afterEach(async ({ request }) => {
+  await deleteDatasets(request, createdDatasets)
+})
+
+test.describe('Géoplateforme sync', () => {
+  test('the geopf tab appears once an eligible file is uploaded, without a reload', async ({ page, request }) => {
+    const uniqueId = Date.now()
+    const dataset = await createDataset(request, `Test geopf eligibility ${uniqueId}`, 'Dataset pour tester la synchronisation cartes.gouv.fr')
+    createdDatasets.push(dataset.id)
+
+    // Seed a non-eligible file
+    const uploadResponse = await request.post(`${API_BASE}/api/1/datasets/${dataset.id}/upload/`, {
+      multipart: {
+        file: {
+          name: `original-${uniqueId}.csv`,
+          mimeType: 'text/csv',
+          buffer: Buffer.from('col_a,col_b\n1,2\n'),
+        },
+      },
+    })
+    if (!uploadResponse.ok()) {
+      throw new Error(`Failed to seed the original file: ${uploadResponse.status()} ${(await uploadResponse.text()).slice(0, 300)}`)
+    }
+
+    await page.goto(`/admin/datasets/${dataset.id}/files`)
+    await page.waitForLoadState('networkidle')
+
+    await expect(page.getByRole('link', { name: 'Synchronisation cartes.gouv.fr' })).not.toBeVisible()
+
+    // Replace the file with a .gpkg: the Files tab's own mutation should tell
+    // the admin layout to recheck eligibility, surfacing the tab with no reload.
+    await page.getByRole('button', { name: 'Éditer le fichier' }).click()
+    const dialog = page.getByRole('dialog')
+    await expect(dialog.getByRole('heading', { name: 'Métadonnées du fichier' })).toBeVisible()
+
+    const fileChooserPromise = page.waitForEvent('filechooser')
+    await dialog.getByRole('button', { name: 'Parcourir' }).click()
+    const fileChooser = await fileChooserPromise
+    await fileChooser.setFiles({
+      name: `replacement-${uniqueId}.gpkg`,
+      mimeType: 'application/geopackage+sqlite3',
+      buffer: Buffer.from('not a real geopackage, only the extension matters here'),
+    })
+    await dialog.getByRole('button', { name: 'Valider' }).click()
+    await expect(page.getByText('Fichier mis à jour !')).toBeVisible()
+
+    await expect(page.getByRole('link', { name: 'Synchronisation cartes.gouv.fr' })).toBeVisible()
+  })
+
+  test('shows the disconnected banner and blocks push when not linked to Géoplateforme', async ({ page, request }) => {
+    const uniqueId = Date.now()
+    const dataset = await createDataset(request, `Test geopf disconnected ${uniqueId}`, 'Dataset pour tester l\'état déconnecté')
+    createdDatasets.push(dataset.id)
+    await createRemoteResource(request, dataset.id, `communes-${uniqueId}`, { format: 'gpkg' })
+
+    await page.goto(`/admin/datasets/${dataset.id}/geopf`)
+    await page.waitForLoadState('networkidle')
+
+    await expect(page.getByText('Non connecté à cartes.gouv.fr')).toBeVisible()
+    const connectLink = page.getByRole('link', { name: 'Se connecter' })
+    await expect(connectLink).toBeVisible()
+    await expect(connectLink).toHaveAttribute('href', new RegExp(`/api/1/geopf/login/\\?dataset_id=${dataset.id}`))
+
+    await expect(page.getByRole('button', { name: 'Envoyer vers cartes.gouv.fr' })).toBeDisabled()
+  })
+
+  test('a resource synced with geopf cannot be edited from the Files tab', async ({ page, request }) => {
+    const uniqueId = Date.now()
+    const dataset = await createDataset(request, `Test geopf synced resource ${uniqueId}`, 'Dataset pour tester l\'édition')
+    createdDatasets.push(dataset.id)
+    await createRemoteResource(request, dataset.id, `geopf-done-${uniqueId}`)
+    await createRemoteResource(request, dataset.id, `geopf-untouched-${uniqueId}`)
+
+    // resource.geopf is readonly, only ever set by the real push/pull flow: serve the
+    // real Files-tab payload back with the first resource patched as synced.
+    const payload = await (await request.get(`${API_BASE}/api/2/datasets/${dataset.id}/resources/`)).json()
+    const syncedResource = payload.data.find((r: { title: string }) => r.title === `geopf-done-${uniqueId}`)
+    syncedResource.geopf = { push_status: 'done' }
+
+    await page.route(new RegExp(`/api/2/datasets/${dataset.id}/resources/`), route => route.fulfill({ json: payload }))
+
+    await page.goto(`/admin/datasets/${dataset.id}/files`)
+    await page.waitForLoadState('networkidle')
+
+    const syncedRow = page.locator('tbody tr').filter({ hasText: `geopf-done-${uniqueId}` })
+    await expect(syncedRow.getByRole('button', { name: 'Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr' })).toBeDisabled()
+
+    const untouchedRow = page.locator('tbody tr').filter({ hasText: `geopf-untouched-${uniqueId}` })
+    await expect(untouchedRow.getByRole('button', { name: 'Éditer le fichier' })).toBeEnabled()
+  })
+})
diff --git a/tests/helpers.ts b/tests/helpers.ts
index a786a8e3f..3188ef70b 100644
--- a/tests/helpers.ts
+++ b/tests/helpers.ts
@@ -47,16 +47,21 @@ export async function createDataset(request: APIRequestContext, title: string, d
   return await response.json()
 }
 
-export async function createRemoteResource(request: APIRequestContext, datasetId: string, title: string): Promise<ApiResource> {
+export async function createRemoteResource(request: APIRequestContext, datasetId: string, title: string, options: { format?: string, extras?: Record<string, unknown> } = {}): Promise<ApiResource> {
+  const { format = 'csv', extras } = options
   const response = await request.post(`${API_BASE}/api/1/datasets/${datasetId}/resources/`, {
     data: {
       title,
       type: 'main',
       filetype: 'remote',
-      url: `https://example.com/${datasetId}/${encodeURIComponent(title)}.csv`,
-      format: 'csv',
+      url: `https://example.com/${datasetId}/${encodeURIComponent(title)}.${format}`,
+      format,
+      ...(extras ? { extras } : {}),
     },
   })
+  if (!response.ok()) {
+    throw new Error(`Failed to create resource "${title}": ${response.status()} ${(await response.text()).slice(0, 300)}`)
+  }
   return await response.json()
 }
 
diff --git a/utils/geopf.ts b/utils/geopf.ts
new file mode 100644
index 000000000..226b6d8b6
--- /dev/null
+++ b/utils/geopf.ts
@@ -0,0 +1,66 @@
+export { isGeopfSynced } from '@datagouv/components-next'
+
+export type GeopfPushStatus = 'pending' | 'done' | 'error' | 'timeout'
+export type GeopfPullStatus = 'pending' | 'done' | 'error'
+
+export type GeopfPushableResource = {
+  id: string
+  title: string
+  format: string | null
+  url: string | null
+  push: {
+    status: GeopfPushStatus | null
+    last_synced_at: string | null
+    error: string | null
+    task_id: string | null
+    stored_data_id: string | null
+  }
+}
+
+export type GeopfOfferingResource = {
+  id: string
+  title: string
+  format: string | null
+  url: string | null
+  offering: {
+    id: string
+    last_synced_at: string | null
+  }
+}
+
+// Shape of `GET /api/1/geopf/status/<dataset_id>/`
+export type GeopfDatasetStatus = {
+  push: {
+    datastore_id: string | null
+    fiche_url: string | null
+  }
+  pull: {
+    status: GeopfPullStatus | null
+    last_synced_at: string | null
+    error: string | null
+    task_id: string | null
+  }
+  pushable: Array<GeopfPushableResource>
+  offerings: Array<GeopfOfferingResource>
+}
+
+export function geopfDatasetStatusUrl(datasetId: string): string {
+  return `/api/1/geopf/status/${datasetId}/`
+}
+
+// Shared by the admin dataset layout and the sync page, so both read one useAsyncData entry.
+export function geopfDatasetStatusKey(datasetId: string): string {
+  return `geopf-status-${datasetId}`
+}
+
+export type GeopfDatastore = {
+  datastore_id: string
+  name: string
+}
+
+// Push and pull answer 424 when not connected; the global $api handler swallows it.
+export function isGeopfReauthRequired(error: unknown): boolean {
+  if (!error || typeof error !== 'object' || !('response' in error)) return false
+  const response = (error as { response?: { status?: number } }).response
+  return response?.status === 424
+}
diff --git a/utils/helpers.ts b/utils/helpers.ts
index f73df18b3..a7f44cc15 100644
--- a/utils/helpers.ts
+++ b/utils/helpers.ts
@@ -28,9 +28,13 @@ function trimEndSlash(url: string): string {
 export function useIsCurrentUrl() {
   const absoluteUrlToRelative = useAbsoluteUrlToRelative()
   const route = useRoute()
+  const router = useRouter()
 
   return (url: string): boolean => {
-    return trimEndSlash(absoluteUrlToRelative(url)) === trimEndSlash(route.fullPath)
+    // Compare paths only: nav/tab links never carry a query string of their own,
+    // so a route with one (e.g. `?flash=connected`) shouldn't fail the match.
+    const urlPath = router.resolve(absoluteUrlToRelative(url)).path
+    return trimEndSlash(urlPath) === trimEndSlash(route.path)
   }
 }