diff --git a/src/assets/languageAssets/cs.js b/src/assets/languageAssets/cs.js
index 6640263e..0cd568d5 100644
--- a/src/assets/languageAssets/cs.js
+++ b/src/assets/languageAssets/cs.js
@@ -88,6 +88,12 @@ Výsledky můžete také **sdílet 📤** a spolupracovat s ostatními uživatel
             apiEndpoint: 'API endpoint GBIF',
             howToContribute:
                 "Pokud chcete přispět k otevřeným datům pozorování biodiverzity agregovaným v GBIF, můžete využít kolaborativní platformy jako <a target='_blank' href='https://www.inaturalist.org/'>iNaturalist</a>, <a target='_blank' href='https://plantnet.org/'>Pl{'@'}ntNet</a> nebo <a target='_blank' href='https://observation.org/'>Observation.org</a>.",
+            progress: {
+                fetching: 'Načítání pozorování...',
+                processing: 'Zpracování dat...',
+                enriching: 'Získávání informací o taxonech...',
+                finalizing: 'Dokončování...',
+            },
         },
         geonature: {
             api_endpoint: 'API endpoint GeoNature',
diff --git a/src/assets/languageAssets/de.js b/src/assets/languageAssets/de.js
index 844d2dae..9fc562a7 100644
--- a/src/assets/languageAssets/de.js
+++ b/src/assets/languageAssets/de.js
@@ -88,6 +88,12 @@ Sie können Ihre Ergebnisse außerdem **teilen 📤**, um mit anderen Nutzern zu
             apiEndpoint: 'API-Adresse von GBIF',
             howToContribute:
                 "Wenn Sie zu den offenen Biodiversitätsbeobachtungsdaten beitragen möchten, die im GBIF aggregiert sind, können Sie kollaborative Plattformen wie <a target='_blank' href='https://www.inaturalist.org/'>iNaturalist</a>, <a target='_blank' href='https://plantnet.org/'>Pl{'@'}ntNet</a> oder <a target='_blank' href='https://observation.org/'>Observation.org</a> nutzen.",
+            progress: {
+                fetching: 'Beobachtungen abrufen...',
+                processing: 'Daten verarbeiten...',
+                enriching: 'Taxon-Informationen abrufen...',
+                finalizing: 'Abschließen...',
+            },
         },
         geonature: {
             api_endpoint: 'API-Adresse von GeoNature',
diff --git a/src/assets/languageAssets/en.js b/src/assets/languageAssets/en.js
index 0004fd6a..119ef3c7 100644
--- a/src/assets/languageAssets/en.js
+++ b/src/assets/languageAssets/en.js
@@ -89,6 +89,12 @@ You can also **share your results 📤** to collaborate with other users.
             apiEndpoint: 'API endpoint of the GBIF',
             howToContribute:
                 "If you would like to contribute to the open biodiversity observation data aggregated in GBIF, you can use collaborative platforms such as <a target='_blank' href='https://www.inaturalist.org/'>iNaturalist</a>, <a target='_blank' href='https://plantnet.org/'>Pl{'@'}ntNet</a> or <a target='_blank' href='https://observation.org/'>Observation.org</a>.",
+            progress: {
+                fetching: 'Fetching observations...',
+                processing: 'Processing data...',
+                enriching: 'Retrieving latest taxon information...',
+                finalizing: 'Finalizing...',
+            },
         },
         geonature: {
             api_endpoint: 'GeoNature  API endpoint',
diff --git a/src/assets/languageAssets/es.js b/src/assets/languageAssets/es.js
index 5feaa357..f9266aa1 100644
--- a/src/assets/languageAssets/es.js
+++ b/src/assets/languageAssets/es.js
@@ -83,6 +83,12 @@ También puedes **compartir tus resultados 📤** para colaborar con otros usuar
             apiEndpoint: 'Punto final de la API de GBIF',
             howToContribute:
                 "Si desea contribuir a los datos abiertos de observaciones de biodiversidad agregados en GBIF, puede utilizar plataformas colaborativas como <a target='_blank' href='https://www.inaturalist.org/'>iNaturalist</a>, <a target='_blank' href='https://plantnet.org/'>Pl{'@'}ntNet</a> o <a target='_blank' href='https://observation.org/'>Observation.org</a>.",
+            progress: {
+                fetching: 'Recuperando observaciones...',
+                processing: 'Procesando datos...',
+                enriching: 'Recuperando información de taxones...',
+                finalizing: 'Finalizando...',
+            },
         },
         geonature: {
             api_endpoint: 'Dirección de la API de GeoNature',
diff --git a/src/assets/languageAssets/fr.js b/src/assets/languageAssets/fr.js
index 35693ec4..8eaca8d4 100644
--- a/src/assets/languageAssets/fr.js
+++ b/src/assets/languageAssets/fr.js
@@ -88,6 +88,12 @@ Vous pouvez également **partager vos résultats 📤** pour collaborer avec d'a
             apiEndpoint: "Adresse de l'API du GBIF",
             howToContribute:
                 "Si vous souhaitez contribuer aux données ouvertes d'observations de biodiversité agrégées dans le GBIF, vous pouvez utiliser des plateformes collaboratives comme <a target='_blank' href='https://www.inaturalist.org/'>iNaturalist</a>, <a target='_blank' href='https://plantnet.org/'>Pl{'@'}ntNet</a> ou <a target='_blank' href='https://observation.org/'>Observation.org</a>.",
+            progress: {
+                fetching: 'Récupération des observations...',
+                processing: 'Traitement des données...',
+                enriching: 'Récupération des dernières infos sur les taxons...',
+                finalizing: 'Finalisation...',
+            },
         },
         geonature: {
             api_endpoint: "Adresse de l'API de GeoNature",
diff --git a/src/assets/languageAssets/it.js b/src/assets/languageAssets/it.js
index 4973aa7d..3dac0a69 100644
--- a/src/assets/languageAssets/it.js
+++ b/src/assets/languageAssets/it.js
@@ -89,6 +89,12 @@ Puoi anche **condividere i tuoi risultati 📤** per collaborare con altri utent
             apiEndpoint: 'Indirizzo API del GBIF',
             howToContribute:
                 "Se desideri contribuire ai dati aperti sulle osservazioni della biodiversità aggregati nel GBIF, puoi utilizzare piattaforme collaborative come <a target='_blank' href='https://www.inaturalist.org/'>iNaturalist</a>, <a target='_blank' href='https://plantnet.org/'>Pl@ntNet</a> o <a target='_blank' href='https://observation.org/'>Observation.org</a>.",
+            progress: {
+                fetching: 'Recupero delle osservazioni...',
+                processing: 'Elaborazione dei dati...',
+                enriching: 'Recupero delle informazioni sui taxon...',
+                finalizing: 'Finalizzazione...',
+            },
         },
         geonature: {
             api_endpoint: 'Indirizzo API di GeoNature',
diff --git a/src/components/commons/ProgressBar.vue b/src/components/commons/ProgressBar.vue
new file mode 100644
index 00000000..0b425356
--- /dev/null
+++ b/src/components/commons/ProgressBar.vue
@@ -0,0 +1,120 @@
+<script setup>
+    import { ref, watch, computed } from 'vue';
+    import ParameterStore from '@/lib/parameterStore';
+
+    const { primaryColor } = ParameterStore.getInstance();
+
+    const props = defineProps({
+        progress: {
+            type: Number,
+            default: 0,
+            validator: (value) => value >= 0 && value <= 100,
+        },
+        message: {
+            type: String,
+            default: '',
+        },
+    });
+
+    const currentProgress = ref(props.progress);
+
+    watch(
+        () => props.progress,
+        (newVal) => {
+            currentProgress.value = newVal;
+        }
+    );
+
+    const progressWidth = computed(() => `${currentProgress.value}%`);
+    const primaryColorHex = computed(() =>
+        primaryColor.value ? `#${primaryColor.value}` : '#444444'
+    );
+</script>
+
+<template>
+    <div class="progress-container" data-testid="ProgressBar component">
+        <div class="progress-card">
+            <div class="progress-bar-wrapper">
+                <div class="progress-bar-background">
+                    <div
+                        class="progress-bar-fill"
+                        :style="{ width: progressWidth }"
+                    ></div>
+                </div>
+            </div>
+            <p v-if="message" class="progress-message">{{ message }}</p>
+        </div>
+    </div>
+</template>
+
+<style scoped>
+    .progress-container {
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        padding: 60px 0;
+    }
+
+    .progress-card {
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        background: #ffffff;
+        border-radius: 18px;
+        box-shadow: rgba(0, 0, 0, 0.16) 0px 1px 4px;
+        padding: 30px 50px;
+        transition: all 0.3s ease;
+        min-width: 320px;
+        max-width: 500px;
+    }
+
+    .progress-bar-wrapper {
+        width: 100%;
+        display: flex;
+        flex-direction: column;
+    }
+
+    .progress-bar-background {
+        width: 100%;
+        height: 24px;
+        background: linear-gradient(to right, #f0f0f0, #e8e8e8);
+        border-radius: 12px;
+        overflow: hidden;
+        box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.1);
+        position: relative;
+    }
+
+    .progress-bar-fill {
+        height: 100%;
+        background: v-bind(primaryColorHex);
+        border-radius: 12px;
+        transition: width 0.3s ease;
+        box-shadow: 0 2px 8px v-bind('primaryColorHex + "4D"');
+        position: relative;
+    }
+
+    .progress-message {
+        margin-top: 16px;
+        margin-bottom: 0;
+        font-size: 1rem;
+        font-weight: 500;
+        color: #666;
+        text-align: center;
+        letter-spacing: 0.3px;
+    }
+
+    @media (max-width: 576px) {
+        .progress-card {
+            min-width: 280px;
+            padding: 25px 35px;
+        }
+
+        .progress-percentage {
+            font-size: 1rem;
+        }
+
+        .progress-message {
+            font-size: 0.9rem;
+        }
+    }
+</style>
diff --git a/src/components/core/filters/SourceFilter.vue b/src/components/core/filters/SourceFilter.vue
index b5debd10..fb7ddc5b 100644
--- a/src/components/core/filters/SourceFilter.vue
+++ b/src/components/core/filters/SourceFilter.vue
@@ -5,6 +5,7 @@
     import { getConnector } from '@/lib/connectors/utils';
     import { GeoNatureConnector } from '@/lib/connectors/geonature';
     import { GbifConnector } from '@/lib/connectors/gbif';
+    import { GbifFacetConnector } from '@/lib/connectors/gbiffacet';
     import { CONNECTORS } from '@/lib/connectors/connectors';
 
     const props = defineProps({
@@ -19,6 +20,7 @@
     const sourcesParams = {
         [CONNECTORS.GBIF]: new GbifConnector().getParamsSchema(),
         [CONNECTORS.GeoNature]: new GeoNatureConnector().getParamsSchema(),
+        [CONNECTORS.GBIF_FACET]: new GbifFacetConnector().getParamsSchema(),
     };
 
     const sourceName = ref(connector.value.name);
diff --git a/src/components/core/taxonList/TaxonDetailed.vue b/src/components/core/taxonList/TaxonDetailed.vue
index 422b8e7a..7700ffc1 100644
--- a/src/components/core/taxonList/TaxonDetailed.vue
+++ b/src/components/core/taxonList/TaxonDetailed.vue
@@ -23,10 +23,10 @@
                 :media="props.picture"
                 :alt="props.picture?.urlSource"
             >
-                <img
-                    :src="props.picture?.url"
+                <Image
+                    :imageUrl="props.picture?.url"
                     :alt="props.picture?.urlSource"
-                    data-testid="Taxon picture"
+                    testID="Taxon picture"
                 />
             </FullScreenImage>
             <AudioPlayer
@@ -45,7 +45,7 @@
         <div class="names">
             <div class="vernacular-name">
                 <StatusIcon
-                    v-if="props.status.status"
+                    v-if="props.status?.status"
                     :status="props.status.status"
                     :color="props.status.color"
                     :size="'1.2rem'"
@@ -122,18 +122,27 @@
         bottom: 10px;
         right: 10px;
         z-index: 2;
+        width: auto;
     }
 
-    img {
-        display: block;
+    .audio-overlay {
+        width: auto;
+    }
+
+    .image-container > :not(.audio-overlay):not(.copyright-overlay) {
         width: 100%;
-        height: auto;
-        aspect-ratio: 1;
-        object-fit: cover;
+    }
+
+    :deep(.image-wrapper) {
+        border-radius: 10px 10px 0px 0px;
+        -webkit-border-radius: 10px 10px 0px 0px;
+        -moz-border-radius: 10px 10px 0px 0px;
+    }
+
+    :deep(.image-wrapper img) {
         border-radius: 10px 10px 0px 0px;
         -webkit-border-radius: 10px 10px 0px 0px;
         -moz-border-radius: 10px 10px 0px 0px;
-        margin: 0 auto;
     }
 
     .statistics-wrapper {
diff --git a/src/components/core/taxonList/TaxonList.vue b/src/components/core/taxonList/TaxonList.vue
index d7db541f..5ace17a9 100644
--- a/src/components/core/taxonList/TaxonList.vue
+++ b/src/components/core/taxonList/TaxonList.vue
@@ -81,6 +81,8 @@
         pageIndex,
         loadingObservations,
         loadingError,
+        loadingProgress,
+        loadingMessage,
     } = taxonManager;
 
     const speciesList = computed(() => searchResult.value.taxons);
@@ -168,6 +170,8 @@
                     <TaxonListMessages
                         :loading-error="loadingError"
                         :loading-observations="loadingObservations"
+                        :loading-progress="loadingProgress"
+                        :loading-message="loadingMessage"
                         :species-list="speciesList"
                         :filter-species-list="filteredSpecies"
                     />
diff --git a/src/components/core/taxonList/TaxonListMessages.vue b/src/components/core/taxonList/TaxonListMessages.vue
index d6ca8d6a..d07130ed 100644
--- a/src/components/core/taxonList/TaxonListMessages.vue
+++ b/src/components/core/taxonList/TaxonListMessages.vue
@@ -1,6 +1,7 @@
 <script setup>
     import { computed } from 'vue';
     import Loading from '@/components/commons/Loading.vue';
+    import ProgressBar from '@/components/commons/ProgressBar.vue';
     import ParameterStore from '@/lib/parameterStore';
 
     const parameterStore = ParameterStore.getInstance();
@@ -13,6 +14,14 @@
         loadingError: {
             type: Boolean,
         },
+        loadingProgress: {
+            type: Number,
+            default: 0,
+        },
+        loadingMessage: {
+            type: String,
+            default: '',
+        },
         speciesList: {
             type: Array,
         },
@@ -20,6 +29,16 @@
             type: Array,
         },
     });
+
+    // Determine if we should show progress bar or simple loading spinner
+    const showProgressBar = computed(
+        () => props.loadingObservations && props.loadingProgress > 0
+    );
+
+    const showLoading = computed(
+        () => props.loadingObservations && props.loadingProgress === 0
+    );
+
     // Calcul des états pour l'affichage des messages
     const noGeometry = computed(
         () =>
@@ -46,9 +65,19 @@
 
 <template>
     <div class="message">
+        <!-- Progress bar for connectors with progress reporting -->
+        <ProgressBar
+            v-if="showProgressBar"
+            :progress="props.loadingProgress"
+            :message="props.loadingMessage"
+            class="message-box"
+        />
+
+        <!-- Simple loading spinner for connectors without progress -->
         <Loading
+            v-if="showLoading"
             id="loadingObs"
-            :loadingStatus="props.loadingObservations"
+            :loadingStatus="true"
             class="message-box"
         />
 
diff --git a/src/components/core/taxonList/TaxonThumbnail.vue b/src/components/core/taxonList/TaxonThumbnail.vue
index 7ea069af..6b6eec4c 100644
--- a/src/components/core/taxonList/TaxonThumbnail.vue
+++ b/src/components/core/taxonList/TaxonThumbnail.vue
@@ -47,7 +47,7 @@
             <div class="card-img-overlay">
                 <div class="card-title">
                     <StatusIcon
-                        v-if="props.status.status"
+                        v-if="props.status?.status"
                         :status="props.status.status"
                         :color="props.status.color"
                         :size="'1rem'"
diff --git a/src/components/core/taxonList/TaxonView.vue b/src/components/core/taxonList/TaxonView.vue
index 932886cd..e81205a1 100644
--- a/src/components/core/taxonList/TaxonView.vue
+++ b/src/components/core/taxonList/TaxonView.vue
@@ -34,7 +34,50 @@
 
     function fetchTaxonImage() {
         speciesPhoto.value = [];
-        if (taxon.taxonId) {
+
+        // First priority: use medias array if available
+        if (taxon.medias && taxon.medias.length > 0) {
+            const images = taxon.medias.filter(
+                (m) => m.typeMedia === MediaType.image
+            );
+            if (images.length > 0) {
+                speciesPhoto.value = [...images];
+
+                // For detailed view, fetch full credits if not already present
+                images.forEach((media, index) => {
+                    // Check if media already has full credits (has license field)
+                    if (!media.license && media.source) {
+                        // Use the media source's getCredits method to fetch full credits
+                        connector.value.imageSource
+                            .getCredits(media)
+                            .then((enrichedMedia) => {
+                                // Update the media with full credits
+                                speciesPhoto.value[index] = enrichedMedia;
+                            })
+                            .catch((err) => {
+                                console.warn(
+                                    `Failed to fetch credits for ${media.source}:`,
+                                    err
+                                );
+                            });
+                    }
+                });
+
+                return;
+            }
+        }
+
+        // Second priority: use mediaUrl for backward compatibility
+        if (taxon.mediaUrl) {
+            speciesPhoto.value = [
+                {
+                    url: taxon.mediaUrl,
+                    typeMedia: MediaType.image,
+                },
+            ];
+        }
+        // Last resort: fetch from media source
+        else if (taxon.taxonId) {
             connector.value.imageSource
                 .fetchPicture(taxon.taxonId, connector.value)
                 .then((response) => {
@@ -44,6 +87,19 @@
     }
     function fetchTaxonAudio() {
         speciesAudio.value = null;
+
+        // First priority: use medias array if available (includes full credits)
+        if (taxon.medias && taxon.medias.length > 0) {
+            const sounds = taxon.medias.filter(
+                (m) => m.typeMedia === MediaType.sound
+            );
+            if (sounds.length > 0) {
+                speciesAudio.value = sounds[0];
+                return;
+            }
+        }
+
+        // Fallback: fetch from media source
         if (taxon.taxonId) {
             connector.value.soundSource
                 .fetchSound(taxon.taxonId, connector.value)
@@ -62,21 +118,31 @@
     });
 
     function refreshVernacularName() {
+        if (taxon.vernacularName) {
+            console.log('Vernacular name already exists, no need to fetch it');
+            return;
+        }
         connector.value.fetchVernacularName(taxon.taxonId).then((name) => {
             if (name) {
-                vernacularName.value = name.split(',')[0];
-                taxon.vernacularName = vernacularName.value;
+                taxon.vernacularName = name.split(',')[0];
             }
         });
     }
 
     function fetchStatus(connector: Connector) {
-        connector.fetchTaxonStatus(taxon.taxonId).then((status_) => {
-            status.value = {
-                status: status_,
-                color: connector.getStatusColor(status_),
-            };
-        });
+        connector
+            .fetchTaxonStatus(taxon.taxonId)
+            .then((status_) => {
+                if (status_) {
+                    status.value = {
+                        status: status_,
+                        color: connector.getStatusColor(status_),
+                    };
+                }
+            })
+            .catch((err) => {
+                console.warn('Failed to fetch taxon status:', err);
+            });
     }
 
     fetchTaxonImage();
@@ -94,7 +160,7 @@
         v-if="mode == 'gallery'"
         :picture="mediaDisplayed"
         :audio="speciesAudio"
-        :vernacular-name="vernacularName || taxon.acceptedScientificName"
+        :vernacular-name="taxon.vernacularName || taxon.acceptedScientificName"
         :url-detail-page="fetchDetailUrl(taxon.taxonId)"
         :accepted-scientific-name="taxon.acceptedScientificName"
         :cols="props.cols"
@@ -106,7 +172,7 @@
         :picture="mediaDisplayed"
         :audio="speciesAudio"
         :accepted-scientific-name="taxon.acceptedScientificName"
-        :vernacular-name="vernacularName || taxon.acceptedScientificName"
+        :vernacular-name="taxon.vernacularName || taxon.acceptedScientificName"
         :url-detail-page="fetchDetailUrl(taxon.taxonId)"
         :nb-observations="taxon?.nbObservations"
         :last-seen-date="taxon?.lastSeenDate"
diff --git a/src/components/core/taxonList/taxonListManager.ts b/src/components/core/taxonList/taxonListManager.ts
index 9540206f..328f0adb 100644
--- a/src/components/core/taxonList/taxonListManager.ts
+++ b/src/components/core/taxonList/taxonListManager.ts
@@ -61,6 +61,16 @@ export class TaxonListManager {
      * @type {Ref<boolean>}
      */
     public loadingError: Ref<boolean> = ref(false);
+    /**
+     * The current loading progress (0-100)
+     * @type {Ref<number>}
+     */
+    public loadingProgress: Ref<number> = ref(0);
+    /**
+     * The current loading message
+     * @type {Ref<string>}
+     */
+    public loadingMessage: Ref<string> = ref('');
     /**
      * A computed property that returns the species list to be displayed
      * @type {any}
@@ -113,8 +123,19 @@ export class TaxonListManager {
 
         this.loadingObservations.value = true;
         this.loadingError.value = false;
+        this.loadingProgress.value = 0;
+        this.loadingMessage.value = '';
         this.filteredSpecies.value = [];
 
+        // Configure progress callback
+        this.connector.value.onProgress = (
+            progress: number,
+            message?: string
+        ) => {
+            this.loadingProgress.value = progress;
+            this.loadingMessage.value = message || '';
+        };
+
         this.connector.value
             .fetchOccurrence({
                 geometry: wktParam,
@@ -127,10 +148,14 @@ export class TaxonListManager {
                 this.filteredSpecies.value = response.taxons;
                 this.pageIndex.value = 0;
                 this.loadingObservations.value = false;
+                this.loadingProgress.value = 0;
+                this.loadingMessage.value = '';
             })
             .catch(() => {
                 this.loadingError.value = true;
                 this.loadingObservations.value = false;
+                this.loadingProgress.value = 0;
+                this.loadingMessage.value = '';
             });
     }
 
diff --git a/src/lib/connectors/connector.ts b/src/lib/connectors/connector.ts
index 3569db39..6d35fbc3 100644
--- a/src/lib/connectors/connector.ts
+++ b/src/lib/connectors/connector.ts
@@ -62,6 +62,12 @@ export class Connector {
      */
     scoringSearchClass: SearchScoring = new SearchScoring();
 
+    /**
+     * Optional callback function to report progress during long-running operations
+     * @type {Function}
+     */
+    onProgress?: (progress: number, message?: string) => void;
+
     constructor(options: ConnectorOptions) {
         this.options = options;
 
@@ -69,6 +75,17 @@ export class Connector {
         this.soundSource = this.parseMediaSource(options?.soundSource);
     }
 
+    /**
+     * Helper method to report progress if a callback is configured
+     * @param {number} progress - Progress percentage (0-100)
+     * @param {string} message - Optional message to display
+     */
+    protected reportProgress(progress: number, message?: string): void {
+        if (this.onProgress) {
+            this.onProgress(progress, message);
+        }
+    }
+
     /**
      * Used to parse the imageSource and soundSource parameter.
      * @param {MediaSource | string} mediaSource
@@ -254,7 +271,7 @@ export class Connector {
      * @returns {Promise<string>} A promise that resolves to the conservation status of the taxon.
      */
     fetchTaxonStatus(taxonId: string | number): Promise<IUCNCodeStatus> {
-        return null;
+        return Promise.resolve(null);
     }
 
     /**
@@ -265,6 +282,11 @@ export class Connector {
         return this.name;
     }
 
+    /**
+     * Returns the color associated with a given IUCN conservation status code.
+     * @param {IUCNCodeStatus} status - The IUCN conservation status code.
+     * @returns {string} The color associated with the given IUCN conservation status code.
+     */
     getStatusColor(status: IUCNCodeStatus): string {
         const IUCNStatusColorDICT = {
             NA: '#C1B5A5',
diff --git a/src/lib/connectors/connectors.ts b/src/lib/connectors/connectors.ts
index ebe2c080..5c90d27d 100644
--- a/src/lib/connectors/connectors.ts
+++ b/src/lib/connectors/connectors.ts
@@ -1,4 +1,5 @@
 export enum CONNECTORS {
     GBIF = 'GBIF',
     GeoNature = 'GeoNature',
+    GBIF_FACET = 'GBIF_FACET',
 }
diff --git a/src/lib/connectors/gbiffacet.ts b/src/lib/connectors/gbiffacet.ts
new file mode 100644
index 00000000..a0e3f10b
--- /dev/null
+++ b/src/lib/connectors/gbiffacet.ts
@@ -0,0 +1,439 @@
+import { Connector, ConnectorOptions } from './connector';
+import { Dataset, SearchResult, Taxon, Media, MediaType } from '../models';
+import ParameterStore from '../parameterStore';
+import { NO_IMAGE_URL } from '@/assets/constant';
+import { TAXON_REFERENTIAL } from '../taxonReferential';
+import { getMediaSource, SOURCE_ } from '../media/media';
+import { useI18n } from 'vue-i18n';
+import { CONNECTORS } from './connectors';
+import { GBIFSearchScoring } from './search/gbif';
+import { removeHoles } from './utils';
+import { parse, stringify } from 'wellknown';
+import { fetchJson } from '../utils';
+
+const GBIF_ENDPOINT_DEFAULT = 'https://api.gbif.org/v1';
+const GBIF_DEFAULT_TAXON_LIMIT = 1000;
+const WIKIDATA_SPARQL_ENDPOINT = 'https://query.wikidata.org/sparql';
+
+type OccurrenceParams = Record<string, any>;
+
+interface TaxonWithAncestors extends Taxon {
+    ancestors?: Array<{ id: number; name: string; rank: string }>;
+    iconicTaxonName?: string;
+    iNatId?: string;
+}
+
+interface WikidataBinding {
+    gbifID: { value: string };
+    iNatID?: { value: string };
+    scientificName?: { value: string };
+    commonName?: { value: string };
+    image?: { value: string };
+    kingdomLabel?: { value: string };
+    phylumLabel?: { value: string };
+    classLabel?: { value: string };
+    orderLabel?: { value: string };
+    familyLabel?: { value: string };
+    genusLabel?: { value: string };
+}
+
+interface EnrichedTaxonData {
+    scientificName?: string;
+    commonName?: string;
+    medias?: Media[];
+    iNatId?: string;
+    ancestors?: any[];
+    kingdom?: string;
+    phylum?: string;
+    order?: string;
+    family?: string;
+    genus?: string;
+    iconicTaxonName?: string;
+}
+
+function buildUrl(base: string, params: Record<string, any>): string {
+    const url = new URL(base);
+    Object.entries(params).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            value.forEach((v) => url.searchParams.append(key, v));
+        } else if (value !== undefined && value !== null) {
+            url.searchParams.append(key, value);
+        }
+    });
+    return url.toString();
+}
+
+function callOccurrenceApi(params: OccurrenceParams = {}): Promise<any> {
+    return fetchJson<any>(
+        buildUrl(`${GBIF_ENDPOINT_DEFAULT}/occurrence/search`, params)
+    );
+}
+
+export class GbifFacetConnector extends Connector {
+    name: string;
+    GBIF_ENDPOINT: string;
+    LIMIT: number;
+    NB_PAGES: number = 1;
+    private enrichTaxonomyCache: Map<string, EnrichedTaxonData> = new Map();
+
+    taxonClass2SourceID = {
+        Aves: 212,
+        Mammalia: 359,
+        Reptilia: 358,
+        Amphibia: 131,
+        Insecta: 216,
+        Arachnida: 367,
+        Gastropoda: 225,
+        Bivalvia: 137,
+        Magnoliopsida: 220,
+        Liliopsida: 196,
+        Pinopsida: 194,
+    };
+
+    constructor(options: ConnectorOptions) {
+        super(options);
+        this.name = CONNECTORS.GBIF_FACET;
+        this.GBIF_ENDPOINT = options?.GBIF_ENDPOINT || GBIF_ENDPOINT_DEFAULT;
+        this.LIMIT = options?.LIMIT || GBIF_DEFAULT_TAXON_LIMIT;
+
+        this.referential = TAXON_REFERENTIAL.GBIF;
+        this.imageSource = this.imageSource || getMediaSource(SOURCE_.wikidata);
+        this.soundSource = this.soundSource || getMediaSource(SOURCE_.wikidata);
+
+        this.isSearchOnAPIAvailable = true;
+        this.scoringSearchClass = new GBIFSearchScoring();
+    }
+
+    getParamsSchema(): Array<Record<string, any>> {
+        const { t } = useI18n();
+        return [
+            {
+                name: 'GBIF_ENDPOINT',
+                label: "Adresse de l'API du GBIF",
+                type: String,
+                default: GBIF_ENDPOINT_DEFAULT,
+            },
+            {
+                name: 'LIMIT',
+                label: t('limit'),
+                type: Number,
+                default: GBIF_DEFAULT_TAXON_LIMIT,
+            },
+        ];
+    }
+
+    fetchVernacularName(taxonID: string | number): Promise<string | undefined> {
+        const mapping_language: Record<string, string> = {
+            en: 'eng',
+            fr: 'fra',
+            es: 'spa',
+            cs: 'ces',
+            it: 'ita',
+            de: 'deu',
+        };
+        const currentLanguage = ParameterStore.getInstance().lang.value;
+
+        return fetchJson(
+            `${this.GBIF_ENDPOINT}/species/${taxonID}/vernacularNames?limit=100`
+        ).then((data) => {
+            const match = data.results.find(
+                (r: any) => r.language === mapping_language[currentLanguage]
+            );
+            return match
+                ? match.vernacularName.charAt(0).toUpperCase() +
+                      match.vernacularName.slice(1)
+                : undefined;
+        });
+    }
+
+    private buildWikidataSparql(gbifIds: string[], lang: string): string {
+        const values = gbifIds.map((id) => `"${id}"`).join(' ');
+        return `
+        SELECT ?gbifID ?iNatID ?scientificName ?commonName ?image
+               ?kingdomLabel ?phylumLabel ?classLabel ?orderLabel ?familyLabel ?genusLabel
+        WHERE {
+            VALUES ?gbifID { ${values} }
+            ?taxon wdt:P846 ?gbifID .
+            OPTIONAL { ?taxon wdt:P3151 ?iNatID . }
+            OPTIONAL { ?taxon wdt:P225 ?scientificName . }
+            OPTIONAL { ?taxon p:P1843 ?commonNameStatement .
+                       ?commonNameStatement ps:P1843 ?commonName .
+                       FILTER(LANG(?commonName) = "${lang}")
+            }
+            OPTIONAL { ?taxon wdt:P18 ?image . }
+            
+            # Walk the taxonomy tree to get parent taxon ranks - use scientific names directly
+            OPTIONAL {
+                ?taxon wdt:P171* ?kingdom .
+                ?kingdom wdt:P105 wd:Q36732 .
+                ?kingdom wdt:P225 ?kingdomLabel .
+            }
+            OPTIONAL {
+                ?taxon wdt:P171* ?phylum .
+                ?phylum wdt:P105 wd:Q38348 .
+                ?phylum wdt:P225 ?phylumLabel .
+            }
+            OPTIONAL {
+                ?taxon wdt:P171* ?class .
+                ?class wdt:P105 wd:Q37517 .
+                ?class wdt:P225 ?classLabel .
+            }
+            OPTIONAL {
+                ?taxon wdt:P171* ?order .
+                ?order wdt:P105 wd:Q36602 .
+                ?order wdt:P225 ?orderLabel .
+            }
+            OPTIONAL {
+                ?taxon wdt:P171* ?family .
+                ?family wdt:P105 wd:Q35409 .
+                ?family wdt:P225 ?familyLabel .
+            }
+            OPTIONAL {
+                ?taxon wdt:P171* ?genus .
+                ?genus wdt:P105 wd:Q34740 .
+                ?genus wdt:P225 ?genusLabel .
+            }
+        }
+    `;
+    }
+
+    private async enrichTaxonomy(
+        gbifIds: string[]
+    ): Promise<Map<string, EnrichedTaxonData>> {
+        const uncachedIds = gbifIds.filter(
+            (id) => !this.enrichTaxonomyCache.has(id)
+        );
+        if (!uncachedIds.length) return this.enrichTaxonomyCache;
+        const currentLang = ParameterStore.getInstance().lang.value;
+
+        try {
+            // Fetch all Wikidata data in a single POST (no URL length limit)
+            const sparql = this.buildWikidataSparql(uncachedIds, currentLang);
+            const wikidataResponse = await fetch(WIKIDATA_SPARQL_ENDPOINT, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/sparql-results+json',
+                },
+                body: new URLSearchParams({ query: sparql }),
+            });
+            if (!wikidataResponse.ok)
+                throw new Error(
+                    `Wikidata POST failed: ${wikidataResponse.status}`
+                );
+            const wikidataData = await wikidataResponse.json();
+
+            // Process Wikidata results - now includes parent taxon ranks
+            // Store basic media info (filename) without fetching credits
+            // Credits will be fetched on-demand when detailed view is rendered
+            wikidataData.results.bindings.forEach((b: WikidataBinding) => {
+                const gbifId = b.gbifID.value;
+                let medias: Media[] = [];
+
+                // Store basic media with thumbnail URL and filename for later credit fetching
+                if (b.image?.value) {
+                    const encodedFileName = b.image.value.split('/').pop();
+                    if (encodedFileName) {
+                        // Decode the filename from the Wikidata URL
+                        const fileName = decodeURIComponent(encodedFileName);
+                        medias = [
+                            {
+                                url: `https://commons.wikimedia.org/w/thumb.php?width=400&f=${encodeURIComponent(fileName)}`,
+                                typeMedia: MediaType.image,
+                                source: fileName, // Store decoded filename for later credit fetching
+                            },
+                        ];
+                    }
+                }
+
+                const enrichedData: EnrichedTaxonData = {
+                    scientificName: b.scientificName?.value,
+                    commonName: b.commonName?.value?.replace(/^./, (char) =>
+                        char.toUpperCase()
+                    ),
+                    medias,
+                    iNatId: b.iNatID?.value,
+                    // Parent taxon ranks from Wikidata - eliminates need for iNaturalist
+                    kingdom: b.kingdomLabel?.value,
+                    phylum: b.phylumLabel?.value,
+                    order: b.orderLabel?.value,
+                    family: b.familyLabel?.value,
+                    genus: b.genusLabel?.value,
+                    // Use class as iconicTaxonName for backward compatibility
+                    iconicTaxonName: b.classLabel?.value,
+                };
+
+                this.enrichTaxonomyCache.set(gbifId, enrichedData);
+            });
+        } catch (e) {
+            console.error(`[${this.name}] enrichTaxonomy failed`, e);
+        }
+
+        return this.enrichTaxonomyCache;
+    }
+
+    /* ---------- fetchOccurrence ---------- */
+    fetchOccurrence(params: any = {}): Promise<SearchResult> {
+        super.fetchOccurrence(params);
+        const { t } = useI18n();
+
+        if (params.geometry)
+            params.geometry = stringify(removeHoles(parse(params.geometry)));
+
+        const defaultParams = {
+            facet: ['speciesKey', 'datasetKey'],
+            facetLimit: this.LIMIT,
+            limit: 0,
+            occurrenceStatus: 'PRESENT',
+            basisOfRecord: [
+                'OBSERVATION',
+                'HUMAN_OBSERVATION',
+                'MACHINE_OBSERVATION',
+                'OCCURRENCE',
+            ],
+            hasGeospatialIssue: false,
+            hasCoordinate: true,
+            ...params,
+        };
+
+        if (defaultParams.dateMin && defaultParams.dateMax) {
+            defaultParams.eventDate = `${defaultParams.dateMin},${defaultParams.dateMax}`;
+            delete defaultParams.dateMin;
+            delete defaultParams.dateMax;
+        }
+
+        if (params?.class) {
+            defaultParams.classKey = this.taxonClass2SourceID[params?.class];
+            delete defaultParams.class;
+        }
+
+        // Step 1 (25%): API GBIF call
+        this.reportProgress(25, t('gbif.progress.fetching'));
+
+        return callOccurrenceApi(defaultParams).then(async (gbifData) => {
+            // Step 2 (50%): Extract facets
+            this.reportProgress(50, t('gbif.progress.processing'));
+
+            if (!gbifData.facets || gbifData.facets.length === 0)
+                return { taxons: [], datasets: [] };
+
+            const taxonFacet = gbifData.facets.find(
+                (f: any) => f.field === 'SPECIES_KEY'
+            );
+            const datasetFacet = gbifData.facets.find(
+                (f: any) => f.field === 'DATASET_KEY'
+            );
+
+            const datasets: Dataset[] =
+                datasetFacet?.counts.map((facet: any) => ({
+                    uuid: facet.name,
+                    name: facet.name,
+                    nbObservations: facet.count,
+                })) || [];
+
+            if (!taxonFacet || !taxonFacet.counts)
+                return { taxons: [], datasets };
+
+            // Step 3 (75%): Wikidata enrichment
+            this.reportProgress(75, t('gbif.progress.enriching'));
+
+            // Parallel prefetch: Start Wikidata enrichment immediately, don't await yet
+            const speciesIds = taxonFacet.counts.map((f: any) => f.name);
+            const enrichmentPromise = this.enrichTaxonomy(speciesIds);
+
+            // Do any other synchronous work here while Wikidata fetches in parallel
+            // (In this case, datasets are already processed above)
+
+            // Now await the enrichment data
+            const enrichmentMap = await enrichmentPromise;
+
+            // Step 4 (100%): Build taxons
+            this.reportProgress(100, t('gbif.progress.finalizing'));
+
+            const taxons: TaxonWithAncestors[] = taxonFacet.counts.map(
+                (facet: any) => {
+                    const gbifId = facet.name;
+                    const enrichment = enrichmentMap.get(gbifId);
+
+                    // For backward compatibility, set mediaUrl to first image or NO_IMAGE_URL
+                    const firstImageUrl =
+                        enrichment?.medias?.find(
+                            (m) => m.typeMedia === MediaType.image
+                        )?.url || NO_IMAGE_URL;
+
+                    const taxon: Taxon = {
+                        taxonId: gbifId,
+                        acceptedScientificName:
+                            enrichment?.scientificName || '',
+                        vernacularName: enrichment?.commonName || '',
+                        taxonRank: 'SPECIES',
+                        nbObservations: facet.count,
+                        mediaUrl: firstImageUrl, // Backward compatibility
+                        medias: enrichment?.medias || [],
+                        description: '',
+                        lastSeenDate: new Date(),
+                        kingdom: enrichment?.kingdom || '',
+                        class: enrichment?.iconicTaxonName || '',
+                    };
+
+                    return taxon;
+                }
+            );
+
+            return { taxons, datasets };
+        });
+    }
+
+    fetchTaxonInfo(idTaxon: string) {
+        return fetchJson<any>(`${this.GBIF_ENDPOINT}/species/${idTaxon}`).then(
+            (json) => ({
+                scientificName: json.scientificName,
+                vernacularName: json.vernacularName,
+                rank: json.rank,
+                taxonKey: json.key,
+            })
+        );
+    }
+
+    fetchTaxonStatus(idTaxon: string) {
+        return fetchJson<{ category: string; code: string }>(
+            `${this.GBIF_ENDPOINT}/species/${idTaxon}/iucnRedListCategory`
+        ).then((json) => json.code);
+    }
+
+    searchTaxon(searchString: string = '', params: OccurrenceParams = {}) {
+        return fetchJson<any>(
+            `${this.GBIF_ENDPOINT}/species/search?q=${searchString}&limit=20`
+        ).then((json) =>
+            json.results.map((e: any) => ({
+                scientificName: e.scientificName,
+                taxonKey: e.key,
+            }))
+        );
+    }
+
+    getTaxonDetailPage(taxonId: string) {
+        return `https://www.gbif.org/species/${taxonId}`;
+    }
+
+    sourceDetailMessage() {
+        return useI18n().t('source.gbifWarning', {
+            nbObs: this.LIMIT * this.NB_PAGES,
+        });
+    }
+
+    getSourceUrl() {
+        return 'https://www.gbif.org';
+    }
+    getDatasetUrl(datasetID: any) {
+        return `${this.getSourceUrl()}/dataset/${datasetID}`;
+    }
+
+    searchOnAPI(searchString: string) {
+        return fetchJson<any>(
+            `${this.GBIF_ENDPOINT}/species/search?q=${searchString}&status=ACCEPTED&qField=VERNACULAR&limit=100`
+        ).then((json) => json.results);
+    }
+}
+
+export default GbifFacetConnector;
diff --git a/src/lib/connectors/geonature.ts b/src/lib/connectors/geonature.ts
index 024ca01b..1db82d26 100644
--- a/src/lib/connectors/geonature.ts
+++ b/src/lib/connectors/geonature.ts
@@ -138,10 +138,9 @@ export class GeoNatureConnector extends Connector {
     }
 
     fetchTaxonStatus(idTaxon: string): Promise<any> {
-        const url = `https://taxref.mnhn.fr/api/taxa/${idTaxon}/status/columns`;
-        return fetch(url)
-            .then((response) => response.json())
-            .then((json) => json._embedded?.status);
+        // GeoNature uses Taxref status system, not IUCN Red List
+        // Return null to indicate IUCN status is not available
+        return Promise.resolve(null);
     }
 
     getTaxonDetailPage(taxonId: string): string {
diff --git a/src/lib/connectors/utils.ts b/src/lib/connectors/utils.ts
index 4c5c31c4..82303ce9 100644
--- a/src/lib/connectors/utils.ts
+++ b/src/lib/connectors/utils.ts
@@ -1,6 +1,7 @@
 import { CONNECTORS } from './connectors';
 import { GbifConnector } from './gbif';
 import { GeoNatureConnector } from './geonature';
+import { GbifFacetConnector } from './gbiffacet';
 import { Connector } from './connector';
 import { simplify, truncate } from '@turf/turf';
 import { Feature, Polygon, MultiPolygon } from 'geojson';
@@ -17,8 +18,10 @@ export function getConnector(
             return new GbifConnector(params);
         case CONNECTORS.GeoNature:
             return new GeoNatureConnector(params);
+        case CONNECTORS.GBIF_FACET:
+            return new GbifFacetConnector(params);
         default:
-            return new GbifConnector(params);
+            return new GbifFacetConnector(params);
     }
 }
 
diff --git a/src/lib/media/MediaSource.ts b/src/lib/media/MediaSource.ts
index cfcf8d7f..31c0c3e3 100644
--- a/src/lib/media/MediaSource.ts
+++ b/src/lib/media/MediaSource.ts
@@ -37,4 +37,15 @@ export abstract class MediaSource {
         }
         return new Promise((_) => null);
     }
+
+    /**
+     * Returns the credits for a given media item. Used when the media
+     * are fetched without credits information,
+     * to enrich them with the necessary details to be displayed in the UI.
+     * @param {Media} media - The media item.
+     * @returns {Promise<Media>} The media item with credits information.
+     */
+    getCredits(media: Media): Promise<Media> {
+        throw new Error('Not implemented');
+    }
 }
diff --git a/src/lib/media/Wikidata.ts b/src/lib/media/Wikidata.ts
index f6246a03..b30c64ff 100644
--- a/src/lib/media/Wikidata.ts
+++ b/src/lib/media/Wikidata.ts
@@ -43,59 +43,6 @@ function fetchWikidataEntityByProperty(
         });
 }
 
-/**
- * Fetch metadata for a Commons file (image or audio)
- */
-function fetchCommonsMedia(
-    fileName: string,
-    typeMedia: MediaType
-): Promise<Media[]> {
-    const commonsUrl = `https://commons.wikimedia.org/w/api.php?action=query&titles=File:${encodeURIComponent(
-        fileName
-    )}&prop=imageinfo&iiprop=url|extmetadata&format=json&origin=*`;
-
-    return fetch(commonsUrl)
-        .then((res) => res.json())
-        .then((commonsData) => {
-            const pages = commonsData.query.pages;
-            const page = Object.values(pages)[0] as any;
-
-            if (!page?.imageinfo?.length) {
-                return [];
-            }
-
-            const info = page.imageinfo[0];
-            const meta = info.extmetadata || {};
-            const credit = {
-                artist: meta.Artist?.value || null,
-                license: meta.LicenseShortName?.value || null,
-                creditLine: meta.Credit?.value || null,
-                licenseUrl: meta.LicenseUrl?.value || null,
-            };
-
-            return [
-                {
-                    url:
-                        typeMedia === MediaType.image
-                            ? `https://commons.wikimedia.org/w/thumb.php?width=700&f=${fileName}`
-                            : info.url,
-                    source: `${
-                        credit.artist
-                            ? credit.artist.replace(/<[^>]*>?/gm, '')
-                            : ''
-                    } - ${credit.license}`,
-                    typeMedia,
-                    licenseUrl: credit.licenseUrl,
-                    license: credit.license,
-                    author: credit.artist
-                        ? credit.artist.replace(/<[^>]*>?/gm, '')
-                        : credit.artist,
-                    urlSource: `https://commons.wikimedia.org/wiki/File:${fileName}`,
-                },
-            ] as Media[];
-        });
-}
-
 /**
  * Generic fetcher for Wikidata media (image/audio)
  */
@@ -122,7 +69,52 @@ function fetchMediaFromWikidata(
             }
 
             const fileName = mediaClaims[0].mainsnak.datavalue.value;
-            return fetchCommonsMedia(fileName, typeMedia);
+
+            // Inline fetch Commons metadata
+            const commonsUrl = `https://commons.wikimedia.org/w/api.php?action=query&titles=File:${encodeURIComponent(
+                fileName
+            )}&prop=imageinfo&iiprop=url|extmetadata&format=json&origin=*`;
+
+            return fetch(commonsUrl)
+                .then((res) => res.json())
+                .then((commonsData) => {
+                    const pages = commonsData.query.pages;
+                    const page = Object.values(pages)[0] as any;
+
+                    if (!page?.imageinfo?.length) {
+                        return [];
+                    }
+
+                    const info = page.imageinfo[0];
+                    const meta = info.extmetadata || {};
+                    const credit = {
+                        artist: meta.Artist?.value || null,
+                        license: meta.LicenseShortName?.value || null,
+                        creditLine: meta.Credit?.value || null,
+                        licenseUrl: meta.LicenseUrl?.value || null,
+                    };
+
+                    return [
+                        {
+                            url:
+                                typeMedia === MediaType.image
+                                    ? `https://commons.wikimedia.org/w/thumb.php?width=700&f=${fileName}`
+                                    : info.url,
+                            source: `${
+                                credit.artist
+                                    ? credit.artist.replace(/<[^>]*>?/gm, '')
+                                    : ''
+                            } - ${credit.license}`,
+                            typeMedia,
+                            licenseUrl: credit.licenseUrl,
+                            license: credit.license,
+                            author: credit.artist
+                                ? credit.artist.replace(/<[^>]*>?/gm, '')
+                                : credit.artist,
+                            urlSource: `https://commons.wikimedia.org/wiki/File:${fileName}`,
+                        },
+                    ] as Media[];
+                });
         });
 }
 
@@ -207,6 +199,66 @@ class WikiDataImageSource extends MediaSource {
     isCompatible(connector: any): boolean {
         return [GBIF, TAXREF].includes(connector.referential);
     }
+
+    /**
+     * Fetch full credits for a media item that only has basic info.
+     * Expects the filename to be stored in media.source field.
+     * @param {Media} media - The media item with basic info (must have source field with filename)
+     * @returns {Promise<Media>} The media item enriched with full credits
+     */
+    async getCredits(media: Media): Promise<Media> {
+        if (!media.source) {
+            throw new Error('Media source field must contain the filename');
+        }
+
+        const fileName = media.source;
+        const typeMedia = media.typeMedia;
+
+        // Fetch metadata from Commons API
+        const commonsUrl = `https://commons.wikimedia.org/w/api.php?action=query&titles=File:${encodeURIComponent(
+            fileName
+        )}&prop=imageinfo&iiprop=url|extmetadata&format=json&origin=*`;
+
+        try {
+            const res = await fetch(commonsUrl);
+            const commonsData = await res.json();
+            const pages = commonsData.query.pages;
+            const page = Object.values(pages)[0] as any;
+
+            if (!page?.imageinfo?.length) {
+                return media; // Return original if no info found
+            }
+
+            const info = page.imageinfo[0];
+            const meta = info.extmetadata || {};
+            const credit = {
+                artist: meta.Artist?.value || null,
+                license: meta.LicenseShortName?.value || null,
+                creditLine: meta.Credit?.value || null,
+                licenseUrl: meta.LicenseUrl?.value || null,
+            };
+
+            return {
+                url:
+                    typeMedia === MediaType.image
+                        ? `https://commons.wikimedia.org/w/thumb.php?width=700&f=${fileName}`
+                        : info.url,
+                source: `${
+                    credit.artist ? credit.artist.replace(/<[^>]*>?/gm, '') : ''
+                } - ${credit.license}`,
+                typeMedia,
+                licenseUrl: credit.licenseUrl,
+                license: credit.license,
+                author: credit.artist
+                    ? credit.artist.replace(/<[^>]*>?/gm, '')
+                    : credit.artist,
+                urlSource: `https://commons.wikimedia.org/wiki/File:${fileName}`,
+            } as Media;
+        } catch (error) {
+            console.error('Failed to fetch Commons media credits:', error);
+            return media; // Return original on error
+        }
+    }
 }
 
 export { WikiDataImageSource };
diff --git a/src/lib/models.ts b/src/lib/models.ts
index 611e500c..ab9b7e55 100644
--- a/src/lib/models.ts
+++ b/src/lib/models.ts
@@ -3,13 +3,18 @@ export interface Taxon {
     acceptedScientificName: string;
     vernacularName?: string;
     nbObservations?: number;
-    mediaUrl?: string;
+    mediaUrl?: string; // Deprecated: use medias instead
+    medias?: Media[];
     taxonRank?: string;
     description?: string;
     taxonSheetUrl?: string;
     lastSeenDate?: Date | null;
     kingdom?: string;
     class?: string;
+    phylum?: string;
+    order?: string;
+    family?: string;
+    genus?: string;
 }
 export enum MediaType {
     sound = 'sound',
diff --git a/src/lib/utils.ts b/src/lib/utils.ts
index f6fc7c69..68f4dbcb 100644
--- a/src/lib/utils.ts
+++ b/src/lib/utils.ts
@@ -96,6 +96,19 @@ function isRunningOnMobile() {
     return check;
 }
 
+/**
+ * Fetches JSON data from a given URL and returns it as a promise.
+ * If the HTTP response is not OK, it throws an error with the HTTP status code.
+ * @template T The type of the JSON data to be fetched.
+ * @param {string} url The URL to fetch the JSON data from.
+ * @returns {Promise<T>} A promise resolving to the fetched JSON data.
+ */
+async function fetchJson<T>(url: string): Promise<T> {
+    const response = await fetch(url);
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    return response.json();
+}
+
 export {
     toWKT,
     restoreMapState,
@@ -103,4 +116,5 @@ export {
     getBaseUrl,
     validURL,
     isRunningOnMobile,
+    fetchJson,
 };
diff --git a/tests/configurator.spec.ts b/tests/configurator.spec.ts
index 18990480..9ed2c08c 100644
--- a/tests/configurator.spec.ts
+++ b/tests/configurator.spec.ts
@@ -21,9 +21,7 @@ async function checkForParameterChange(page, key, value) {
 
 test.describe('Form parameters testing', () => {
     test.beforeEach(async ({ page }) => {
-        await page.goto(
-            '/#/config?widgetType=mapList&lang=fr&GBIF_ENDPOINT=https://api.gbif-uat.org/v1/'
-        );
+        await page.goto('/#/config?widgetType=mapList&lang=fr');
     });
 
     test('enable/disable filter', async ({ page }) => {
diff --git a/tests/list.spec.ts b/tests/list.spec.ts
index ea3d5dc2..27008447 100644
--- a/tests/list.spec.ts
+++ b/tests/list.spec.ts
@@ -5,7 +5,7 @@ import { TaxonList } from './page/taxonlistcontroller';
 test.describe('Simple list', () => {
     test.beforeEach(async ({ page }) => {
         await page.goto(
-            'http://localhost:5173/#/?widgetType=list&x=6.076641082763673&y=44.55164823782743&GBIF_ENDPOINT=https://api.gbif-uat.org/v1/&showFilters=true&lang=en&switchModeAvailable=true'
+            'http://localhost:5173/#/?widgetType=list&x=6.076641082763673&y=44.55164823782743&showFilters=true&lang=en&switchModeAvailable=true'
         );
     });
     test('sort', async ({ page }) => {
diff --git a/tests/maplist.spec.ts b/tests/maplist.spec.ts
index cbb626ba..98197313 100644
--- a/tests/maplist.spec.ts
+++ b/tests/maplist.spec.ts
@@ -4,9 +4,7 @@ import { TaxonList } from './page/taxonlistcontroller';
 
 test.describe('Map list', () => {
     test.beforeEach(async ({ page }) => {
-        await page.goto(
-            'http://localhost:5173/#/?GBIF_ENDPOINT=https://api.gbif-uat.org/v1/'
-        );
+        await page.goto('http://localhost:5173/#/');
     });
     test('should load map list', async ({ page }) => {
         await page.locator('.mapC').isVisible();