diff --git a/build.gradle.kts b/build.gradle.kts
index 2d14d6973d1..cee2d416a94 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -66,3 +66,4 @@ tasks.cyclonedxBom {
     componentVersion = project.version.toString()
     componentGroup = "org.jabref"
 }
+
diff --git a/jabgui/src/main/java/org/jabref/gui/externalfiles/ImportHandler.java b/jabgui/src/main/java/org/jabref/gui/externalfiles/ImportHandler.java
index 8d43ed1ac51..1d823f294f8 100644
--- a/jabgui/src/main/java/org/jabref/gui/externalfiles/ImportHandler.java
+++ b/jabgui/src/main/java/org/jabref/gui/externalfiles/ImportHandler.java
@@ -54,6 +54,7 @@
 import org.jabref.model.entry.BibtexString;
 import org.jabref.model.entry.LinkedFile;
 import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.identifier.Identifier;
 import org.jabref.model.groups.GroupEntryChanger;
 import org.jabref.model.groups.GroupTreeNode;
 import org.jabref.model.groups.SmartGroup;
@@ -230,6 +231,9 @@ public void importEntries(List<BibEntry> entries) {
         ImportCleanup cleanup = ImportCleanup.targeting(bibDatabaseContext.getMode(), preferences.getFieldPreferences());
         cleanup.doPostCleanup(entries);
         importCleanedEntries(entries);
+
+        // Check for long keys and show guidance notification
+        checkForLongKeysAndNotify(entries);
     }
 
     public void importCleanedEntries(List<BibEntry> entries) {
@@ -526,4 +530,39 @@ private void addToImportEntriesGroup(List<BibEntry> entriesToInsert) {
                                    .ifPresent(smtGrp -> smtGrp.addEntriesToGroup(entriesToInsert));
         }
     }
+
+    /**
+     * Checks for entries with long citation keys and shows a guidance notification if found.
+     * This helps users understand when they might want to use shorter, more manageable keys.
+     */
+    private void checkForLongKeysAndNotify(List<BibEntry> entries) {
+        if (entries.isEmpty()) {
+            return;
+        }
+
+        // Define threshold for "long" keys (e.g., more than 20 characters)
+        // Temporarily lowered for testing/demo purposes
+        final int LONG_KEY_THRESHOLD = 20;
+
+        List<BibEntry> entriesWithLongKeys = entries.stream()
+                .filter(entry -> {
+                    String citationKey = entry.getCitationKey().orElse("");
+                    return citationKey.length() > LONG_KEY_THRESHOLD;
+                })
+                .toList();
+
+        if (!entriesWithLongKeys.isEmpty()) {
+            String message = Localization.lang("Imported %0 entries with long citation keys (>%1 characters). " +
+                    "Consider using shorter keys for better readability and management.",
+                    entriesWithLongKeys.size(), LONG_KEY_THRESHOLD);
+
+            LOGGER.info("Long key detection: Found {} entries with keys longer than {} characters",
+                    entriesWithLongKeys.size(), LONG_KEY_THRESHOLD);
+
+            // Show notification to user
+            UiTaskExecutor.runInJavaFXThread(() ->
+                dialogService.notify(message)
+            );
+        }
+    }
 }
diff --git a/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneView.java b/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneView.java
index d5347ccc061..192d38b94b9 100644
--- a/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneView.java
+++ b/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneView.java
@@ -6,6 +6,7 @@
 import javafx.css.PseudoClass;
 import javafx.scene.control.Button;
 import javafx.scene.control.ComboBox;
+import javafx.scene.control.Label;
 import javafx.scene.control.TextField;
 import javafx.scene.control.Tooltip;
 import javafx.scene.input.KeyCode;
@@ -52,6 +53,7 @@ private void initialize() {
         getChildren().addAll(
                 fetcherContainer,
                 createQueryField(),
+                createIdentifierHint(),
                 createSearchButton()
         );
         this.disableProperty().bind(searchDisabledProperty());
@@ -108,6 +110,34 @@ private TextField createQueryField() {
         return query;
     }
 
+    /**
+     * Create identifier hint label
+     */
+    private Label createIdentifierHint() {
+        Label identifierHint = new Label();
+        identifierHint.getStyleClass().add("identifier-hint");
+        identifierHint.visibleProperty().bind(viewModel.identifierDetectedProperty());
+        
+        // Use EasyBind to create dynamic text binding
+        EasyBind.subscribe(viewModel.identifierDetectedProperty(), detected -> {
+            if (detected) {
+                String identifierType = viewModel.getDetectedIdentifierType();
+                identifierHint.setText(Localization.lang("Detected identifier: %0", identifierType));
+            } else {
+                identifierHint.setText("");
+            }
+        });
+        
+        // Also listen to identifier type changes
+        EasyBind.subscribe(viewModel.detectedIdentifierTypeProperty(), identifierType -> {
+            if (viewModel.isIdentifierDetected()) {
+                identifierHint.setText(Localization.lang("Detected identifier: %0", identifierType));
+            }
+        });
+        
+        return identifierHint;
+    }
+
     /**
      * Create button that triggers search
      */
@@ -147,4 +177,4 @@ private ObservableBooleanValue searchDisabledProperty() {
                 stateManager.getOpenDatabases()
         );
     }
-}
+}
\ No newline at end of file
diff --git a/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneViewModel.java b/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneViewModel.java
index 118a0d6a6dd..d3924066e8a 100644
--- a/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneViewModel.java
+++ b/jabgui/src/main/java/org/jabref/gui/importer/fetcher/WebSearchPaneViewModel.java
@@ -1,9 +1,12 @@
 package org.jabref.gui.importer.fetcher;
 
+import java.util.Optional;
 import java.util.concurrent.Callable;
 
+import javafx.beans.property.BooleanProperty;
 import javafx.beans.property.ListProperty;
 import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
 import javafx.beans.property.SimpleListProperty;
 import javafx.beans.property.SimpleObjectProperty;
 import javafx.beans.property.SimpleStringProperty;
@@ -22,6 +25,7 @@
 import org.jabref.logic.importer.WebFetchers;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.logic.util.BackgroundTask;
+import org.jabref.model.entry.identifier.Identifier;
 import org.jabref.model.search.query.SearchQuery;
 import org.jabref.model.strings.StringUtil;
 import org.jabref.model.util.OptionalUtil;
@@ -34,12 +38,18 @@
 import org.antlr.v4.runtime.RecognitionException;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.misc.ParseCancellationException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class WebSearchPaneViewModel {
+    
+    private static final Logger LOGGER = LoggerFactory.getLogger(WebSearchPaneViewModel.class);
 
     private final ObjectProperty<SearchBasedFetcher> selectedFetcher = new SimpleObjectProperty<>();
     private final ListProperty<SearchBasedFetcher> fetchers = new SimpleListProperty<>(FXCollections.observableArrayList());
     private final StringProperty query = new SimpleStringProperty();
+    private final BooleanProperty identifierDetected = new SimpleBooleanProperty(false);
+    private final StringProperty detectedIdentifierType = new SimpleStringProperty("");
     private final DialogService dialogService;
     private final GuiPreferences preferences;
     private final StateManager stateManager;
@@ -68,6 +78,9 @@ public WebSearchPaneViewModel(GuiPreferences preferences, DialogService dialogSe
             sidePanePreferences.setWebSearchFetcherSelected(newIndex);
         });
 
+        // Subscribe to query changes to detect identifiers
+        EasyBind.subscribe(query, this::updateIdentifierDetection);
+
         searchQueryValidator = new FunctionBasedValidator<>(
                 query,
                 queryText -> {
@@ -94,7 +107,7 @@ public WebSearchPaneViewModel(GuiPreferences preferences, DialogService dialogSe
                             int line = offendingToken.getLine();
                             int charPositionInLine = offendingToken.getCharPositionInLine() + 1;
 
-                            return ValidationMessage.error(Localization.lang("Invalid query element '%0' at position %1", line, charPositionInLine));
+                            return ValidationMessage.error(Localization.lang("Invalid query element '%0' at position %1", offendingToken.getText(), charPositionInLine));
                         }
 
                         // Fallback for other failing reasons
@@ -128,48 +141,116 @@ public StringProperty queryProperty() {
     }
 
     public void search() {
+        String query = getQuery().trim();
+        LOGGER.debug("Starting web search with query: '{}'", query);
+        
         if (!preferences.getImporterPreferences().areImporterEnabled()) {
-            if (!preferences.getImporterPreferences().areImporterEnabled()) {
-                dialogService.notify(Localization.lang("Web search disabled"));
-                return;
-            }
+            LOGGER.warn("Web search attempted but importers are disabled");
+            dialogService.notify(Localization.lang("Web search disabled"));
+            return;
         }
 
-        String query = getQuery().trim();
         if (StringUtil.isBlank(query)) {
+            LOGGER.warn("Web search attempted with empty query");
             dialogService.notify(Localization.lang("Please enter a search string"));
             return;
         }
         if (stateManager.getActiveDatabase().isEmpty()) {
+            LOGGER.warn("Web search attempted but no database is open");
             dialogService.notify(Localization.lang("Please open or start a new library before searching"));
             return;
         }
 
         SearchBasedFetcher activeFetcher = getSelectedFetcher();
+        LOGGER.info("Performing web search using fetcher: {} with query: '{}'", 
+                activeFetcher.getName(), query);
 
         Callable<ParserResult> parserResultCallable;
 
         String fetcherName = activeFetcher.getName();
 
         if (CompositeIdFetcher.containsValidId(query)) {
+            LOGGER.debug("Query contains valid identifier, using CompositeIdFetcher");
             CompositeIdFetcher compositeIdFetcher = new CompositeIdFetcher(preferences.getImportFormatPreferences());
             parserResultCallable = () -> new ParserResult(OptionalUtil.toList(compositeIdFetcher.performSearchById(query)));
             fetcherName = Localization.lang("Identifier-based Web Search");
         } else {
+            LOGGER.debug("Query is a regular search query, using selected fetcher");
             // Exceptions are handled below at "task.onFailure(dialogService::showErrorDialogAndWait)"
             parserResultCallable = () -> new ParserResult(activeFetcher.performSearch(query));
         }
 
         BackgroundTask<ParserResult> task = BackgroundTask.wrap(parserResultCallable)
                                                           .withInitialMessage(Localization.lang("Processing \"%0\"...", query));
-        task.onFailure(dialogService::showErrorDialogAndWait);
+        task.onFailure(exception -> {
+            LOGGER.error("Web search failed for query '{}' using fetcher '{}': {}", 
+                    query, activeFetcher.getName(), exception.getMessage());
+            dialogService.showErrorDialogAndWait(exception);
+        });
 
         ImportEntriesDialog dialog = new ImportEntriesDialog(stateManager.getActiveDatabase().get(), task, activeFetcher, query);
         dialog.setTitle(fetcherName);
         dialogService.showCustomDialogAndWait(dialog);
+        
+        LOGGER.debug("Web search dialog completed for query: '{}'", query);
     }
 
     public ValidationStatus queryValidationStatus() {
         return searchQueryValidator.getValidationStatus();
     }
-}
+
+    public boolean isIdentifierDetected() {
+        return identifierDetected.get();
+    }
+
+    public BooleanProperty identifierDetectedProperty() {
+        return identifierDetected;
+    }
+
+    public String getDetectedIdentifierType() {
+        return detectedIdentifierType.get();
+    }
+
+    public StringProperty detectedIdentifierTypeProperty() {
+        return detectedIdentifierType;
+    }
+
+    private void updateIdentifierDetection(String queryText) {
+        if (StringUtil.isBlank(queryText)) {
+            identifierDetected.set(false);
+            detectedIdentifierType.set("");
+            LOGGER.debug("Identifier detection cleared for empty query");
+            return;
+        }
+
+        Optional<Identifier> identifier = Identifier.from(queryText.trim());
+        if (identifier.isPresent()) {
+            String identifierType = getIdentifierTypeName(identifier.get());
+            identifierDetected.set(true);
+            detectedIdentifierType.set(identifierType);
+            LOGGER.debug("Identifier detected: {} for query: '{}'", identifierType, queryText);
+        } else {
+            identifierDetected.set(false);
+            detectedIdentifierType.set("");
+            LOGGER.debug("No identifier detected for query: '{}'", queryText);
+        }
+    }
+
+    private String getIdentifierTypeName(Identifier identifier) {
+        String className = identifier.getClass().getSimpleName();
+        switch (className) {
+            case "DOI":
+                return Localization.lang("DOI");
+            case "ArXivIdentifier":
+                return Localization.lang("ArXiv");
+            case "ISBN":
+                return Localization.lang("ISBN");
+            case "SSRN":
+                return Localization.lang("SSRN");
+            case "RFC":
+                return Localization.lang("RFC");
+            default:
+                return className;
+        }
+    }
+}
\ No newline at end of file
diff --git a/jabgui/src/main/java/org/jabref/gui/mergeentries/FetchAndMergeEntry.java b/jabgui/src/main/java/org/jabref/gui/mergeentries/FetchAndMergeEntry.java
index 63666e0e464..8e41b8d5411 100644
--- a/jabgui/src/main/java/org/jabref/gui/mergeentries/FetchAndMergeEntry.java
+++ b/jabgui/src/main/java/org/jabref/gui/mergeentries/FetchAndMergeEntry.java
@@ -16,6 +16,7 @@
 import org.jabref.gui.undo.NamedCompoundEdit;
 import org.jabref.gui.undo.UndoableChangeType;
 import org.jabref.gui.undo.UndoableFieldChange;
+import org.jabref.logic.citationkeypattern.CitationKeyGenerator;
 import org.jabref.logic.importer.EntryBasedFetcher;
 import org.jabref.logic.importer.FetcherClientException;
 import org.jabref.logic.importer.FetcherServerException;
@@ -23,6 +24,8 @@
 import org.jabref.logic.importer.ImportCleanup;
 import org.jabref.logic.importer.WebFetcher;
 import org.jabref.logic.importer.WebFetchers;
+import org.jabref.logic.importer.fetcher.ArXivFetcher;
+import org.jabref.logic.importer.fetcher.INSPIREFetcher;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.logic.util.BackgroundTask;
 import org.jabref.logic.util.TaskExecutor;
@@ -172,6 +175,14 @@ public void fetchAndMerge(BibEntry entry, EntryBasedFetcher fetcher) {
                           if (fetchedEntry.isPresent()) {
                               ImportCleanup cleanup = ImportCleanup.targeting(bibDatabaseContext.getMode(), preferences.getFieldPreferences());
                               cleanup.doPostCleanup(fetchedEntry.get());
+
+                              // Generate a new citation key for entries fetched by INSPIREFetcher or ArXivFetcher
+                              // to avoid long key
+                              if (fetcher instanceof INSPIREFetcher || fetcher instanceof ArXivFetcher) {
+                                  CitationKeyGenerator keyGen = new CitationKeyGenerator(bibDatabaseContext, preferences.getCitationKeyPatternPreferences());
+                                  keyGen.generateAndSetKey(fetchedEntry.get());
+                              }
+
                               showMergeDialog(entry, fetchedEntry.get(), fetcher);
                           } else {
                               dialogService.notify(Localization.lang("Could not find any bibliographic information."));
diff --git a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java
index 12064d26e92..ff3ae253b6a 100644
--- a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java
+++ b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTab.java
@@ -45,6 +45,8 @@ public class WebSearchTab extends AbstractPreferenceTabView<WebSearchTabViewMode
     @FXML private CheckBox grobidEnabled;
     @FXML private TextField grobidURL;
 
+    @FXML private CheckBox preferInspireTexkeys;
+
     @FXML private VBox fetchersContainer;
 
     private final ReadOnlyBooleanProperty refAiEnabled;
@@ -119,6 +121,8 @@ public void initialize() {
         useCustomDOIName.textProperty().bindBidirectional(viewModel.useCustomDOINameProperty());
         useCustomDOIName.disableProperty().bind(useCustomDOI.selectedProperty().not());
 
+        preferInspireTexkeys.selectedProperty().bindBidirectional(viewModel.preferInspireTexkeysProperty());
+
         InvalidationListener listener = _ -> fetchersContainer
                 .getChildren()
                 .setAll(viewModel.getFetchers()
diff --git a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java
index dca966ff906..3e707357142 100644
--- a/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java
+++ b/jabgui/src/main/java/org/jabref/gui/preferences/websearch/WebSearchTabViewModel.java
@@ -46,8 +46,12 @@
 import org.jabref.logic.util.TaskExecutor;
 
 import kong.unirest.core.UnirestException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class WebSearchTabViewModel implements PreferenceTabViewModel {
+    
+    private static final Logger LOGGER = LoggerFactory.getLogger(WebSearchTabViewModel.class);
     private final BooleanProperty enableWebSearchProperty = new SimpleBooleanProperty();
     private final BooleanProperty warnAboutDuplicatesOnImportProperty = new SimpleBooleanProperty();
     private final BooleanProperty shouldDownloadLinkedOnlineFiles = new SimpleBooleanProperty();
@@ -69,6 +73,8 @@ public class WebSearchTabViewModel implements PreferenceTabViewModel {
     private final BooleanProperty grobidEnabledProperty = new SimpleBooleanProperty();
     private final StringProperty grobidURLProperty = new SimpleStringProperty("");
 
+    private final BooleanProperty preferInspireTexkeysProperty = new SimpleBooleanProperty();
+
     private final BooleanProperty apikeyPersistProperty = new SimpleBooleanProperty();
     private final BooleanProperty apikeyPersistAvailableProperty = new SimpleBooleanProperty();
 
@@ -138,6 +144,8 @@ private void setupPlainCitationParsers(CliPreferences preferences) {
 
     @Override
     public void setValues() {
+        LOGGER.debug("Setting values for WebSearchTabViewModel");
+        
         enableWebSearchProperty.setValue(importerPreferences.areImporterEnabled());
         warnAboutDuplicatesOnImportProperty.setValue(importerPreferences.shouldWarnAboutDuplicatesOnImport());
         shouldDownloadLinkedOnlineFiles.setValue(filePreferences.shouldDownloadLinkedFiles());
@@ -146,6 +154,11 @@ public void setValues() {
         addImportedEntriesGroupName.setValue(libraryPreferences.getAddImportedEntriesGroupName());
         defaultPlainCitationParser.setValue(importerPreferences.getDefaultPlainCitationParser());
         citationsRelationStoreTTL.setValue(importerPreferences.getCitationsRelationsStoreTTL());
+        
+        LOGGER.debug("Web search enabled: {}, Duplicate warning: {}, Download linked files: {}", 
+                importerPreferences.areImporterEnabled(), 
+                importerPreferences.shouldWarnAboutDuplicatesOnImport(),
+                filePreferences.shouldDownloadLinkedFiles());
 
         useCustomDOIProperty.setValue(doiPreferences.isUseCustom());
         useCustomDOINameProperty.setValue(doiPreferences.getDefaultBaseURI());
@@ -153,6 +166,8 @@ public void setValues() {
         grobidEnabledProperty.setValue(grobidPreferences.isGrobidEnabled());
         grobidURLProperty.setValue(grobidPreferences.getGrobidURL());
 
+        preferInspireTexkeysProperty.setValue(preferences.getImporterPreferences().isPreferInspireTexkeys());
+
         Set<FetcherApiKey> savedApiKeys = preferences.getImporterPreferences().getApiKeys();
         Set<String> enabledCatalogs = new HashSet<>(importerPreferences.getCatalogs());
 
@@ -188,11 +203,18 @@ public void setValues() {
 
     @Override
     public void storeSettings() {
+        LOGGER.debug("Storing WebSearchTabViewModel settings");
+        
         importerPreferences.setImporterEnabled(enableWebSearchProperty.getValue());
         importerPreferences.setWarnAboutDuplicatesOnImport(warnAboutDuplicatesOnImportProperty.getValue());
         filePreferences.setDownloadLinkedFiles(shouldDownloadLinkedOnlineFiles.getValue());
         filePreferences.setKeepDownloadUrl(shouldkeepDownloadUrl.getValue());
         libraryPreferences.setAddImportedEntries(addImportedEntries.getValue());
+        
+        LOGGER.info("Web search settings updated - Enabled: {}, Duplicate warning: {}, Download linked files: {}", 
+                enableWebSearchProperty.getValue(),
+                warnAboutDuplicatesOnImportProperty.getValue(),
+                shouldDownloadLinkedOnlineFiles.getValue());
         if (addImportedEntriesGroupName.getValue().isEmpty() || addImportedEntriesGroupName.getValue().startsWith(" ")) {
             libraryPreferences.setAddImportedEntriesGroupName(Localization.lang("Imported entries"));
         } else {
@@ -207,6 +229,8 @@ public void storeSettings() {
         doiPreferences.setUseCustom(useCustomDOIProperty.get());
         doiPreferences.setDefaultBaseURI(useCustomDOINameProperty.getValue().trim());
 
+        importerPreferences.setPreferInspireTexkeys(preferInspireTexkeysProperty.getValue());
+
         importerPreferences.setCatalogs(
                 fetchers.stream()
                         .filter(FetcherViewModel::isEnabled)
@@ -289,20 +313,29 @@ public IntegerProperty citationsRelationsStoreTTLProperty() {
         return citationsRelationStoreTTL;
     }
 
+    public BooleanProperty preferInspireTexkeysProperty() {
+        return preferInspireTexkeysProperty;
+    }
+
     public void checkApiKey(FetcherViewModel fetcherViewModel, String apiKey, Consumer<Boolean> onFinished) {
+        LOGGER.debug("Checking API key for fetcher: {}", fetcherViewModel.getName());
+        
         Callable<Boolean> tester = () -> {
             WebFetcher webFetcher = fetcherViewModel.getFetcher();
 
             if (!(webFetcher instanceof CustomizableKeyFetcher fetcher)) {
+                LOGGER.warn("Fetcher {} is not a CustomizableKeyFetcher", fetcherViewModel.getName());
                 return false;
             }
 
             String testUrlWithoutApiKey = fetcher.getTestUrl();
             if (testUrlWithoutApiKey == null) {
+                LOGGER.warn("No test URL available for fetcher: {}", fetcherViewModel.getName());
                 return false;
             }
 
             if (apiKey.isEmpty()) {
+                LOGGER.warn("Empty API key provided for fetcher: {}", fetcherViewModel.getName());
                 return false;
             }
 
@@ -310,14 +343,24 @@ public void checkApiKey(FetcherViewModel fetcherViewModel, String apiKey, Consum
                 URLDownload urlDownload = new URLDownload(testUrlWithoutApiKey + apiKey);
                 // The HEAD request cannot be used because its response is not 200 (maybe 404 or 596...).
                 int statusCode = ((HttpURLConnection) urlDownload.getSource().openConnection()).getResponseCode();
-                return (statusCode >= 200) && (statusCode < 300);
+                boolean isValid = (statusCode >= 200) && (statusCode < 300);
+                LOGGER.debug("API key validation for {} returned status code: {}, valid: {}", 
+                        fetcherViewModel.getName(), statusCode, isValid);
+                return isValid;
             } catch (IOException | UnirestException e) {
+                LOGGER.warn("Error validating API key for fetcher {}: {}", fetcherViewModel.getName(), e.getMessage());
                 return false;
             }
         };
         BackgroundTask.wrap(tester)
-                      .onSuccess(onFinished)
-                      .onFailure(_ -> onFinished.accept(false))
+                      .onSuccess(result -> {
+                          LOGGER.info("API key validation completed for {}: {}", fetcherViewModel.getName(), result);
+                          onFinished.accept(result);
+                      })
+                      .onFailure(exception -> {
+                          LOGGER.error("API key validation failed for {}: {}", fetcherViewModel.getName(), exception.getMessage());
+                          onFinished.accept(false);
+                      })
                       .executeWith(taskExecutor);
     }
 
diff --git a/jabgui/src/main/resources/images/Icons.properties b/jabgui/src/main/resources/images/Icons.properties
index 8caa86aa6ad..2aaa10d313d 100644
--- a/jabgui/src/main/resources/images/Icons.properties
+++ b/jabgui/src/main/resources/images/Icons.properties
@@ -6,3 +6,5 @@ jabrefIcon40=JabRef-icon-40.png
 jabrefIcon48=JabRef-icon-48.png
 jabrefIcon64=JabRef-icon-64.png
 jabrefIcon128=JabRef-icon-128.png
+INSPIRE\ preferences=Create property
+Prefer\ INSPIRE\ texkeys;\ clean\ URL-like\ citation\ keys=Create property
diff --git a/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml b/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml
index cf9d45183de..db25d349073 100644
--- a/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml
+++ b/jabgui/src/main/resources/org/jabref/gui/preferences/websearch/WebSearchTab.fxml
@@ -47,6 +47,11 @@
         <TextField fx:id="grobidURL" HBox.hgrow="ALWAYS"/>
     </HBox>
 
+    <Label styleClass="sectionHeader" text="%INSPIRE preferences"/>
+    <FlowPane styleClass="checkbox-flowpane">
+        <CheckBox fx:id="preferInspireTexkeys" text="%Prefer INSPIRE texkeys; clean URL-like citation keys"/>
+    </FlowPane>
+
     <Label styleClass="sectionHeader" text="%Web search fetchers"/>
     <VBox fx:id="fetchersContainer"/>
 </fx:root>
diff --git a/jabgui/src/test/java/org/jabref/gui/importer/fetcher/WebSearchPaneViewModelIdentifierTest.java b/jabgui/src/test/java/org/jabref/gui/importer/fetcher/WebSearchPaneViewModelIdentifierTest.java
new file mode 100644
index 00000000000..a130835bc61
--- /dev/null
+++ b/jabgui/src/test/java/org/jabref/gui/importer/fetcher/WebSearchPaneViewModelIdentifierTest.java
@@ -0,0 +1,34 @@
+package org.jabref.gui.importer.fetcher;
+
+import org.jabref.gui.DialogService;
+import org.jabref.gui.StateManager;
+import org.jabref.gui.preferences.GuiPreferences;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+class WebSearchPaneViewModelIdentifierTest {
+
+    private WebSearchPaneViewModel vm() {
+        GuiPreferences prefs = mock(GuiPreferences.class, RETURNS_DEEP_STUBS);
+        DialogService dialog = mock(DialogService.class);
+        StateManager state = mock(StateManager.class);
+        return new WebSearchPaneViewModel(prefs, dialog, state);
+    }
+
+    @ParameterizedTest
+    @CsvSource({
+        "10.1145/3368089,DOI",
+        "arXiv:2101.00001,ArXiv",
+        "978-3-16-148410-0,ISBN"
+    })
+    void detectsIdentifierType(String input, String expected) {
+        var vm = vm();
+        vm.queryProperty().set(input);
+        assertTrue(vm.isIdentifierDetected());
+        assertEquals(expected, vm.getDetectedIdentifierType());
+    }
+}
+
diff --git a/jablib/src/main/java/org/jabref/logic/importer/CompositeIdFetcher.java b/jablib/src/main/java/org/jabref/logic/importer/CompositeIdFetcher.java
index 3c54f268121..02a70048830 100644
--- a/jablib/src/main/java/org/jabref/logic/importer/CompositeIdFetcher.java
+++ b/jablib/src/main/java/org/jabref/logic/importer/CompositeIdFetcher.java
@@ -6,6 +6,7 @@
 import org.jabref.logic.importer.fetcher.DoiFetcher;
 import org.jabref.logic.importer.fetcher.RfcFetcher;
 import org.jabref.logic.importer.fetcher.isbntobibtex.IsbnFetcher;
+import org.jabref.logic.importer.fetcher.INSPIREFetcher;
 import org.jabref.model.entry.BibEntry;
 import org.jabref.model.entry.identifier.ArXivIdentifier;
 import org.jabref.model.entry.identifier.DOI;
@@ -31,6 +32,15 @@ public Optional<BibEntry> performSearchById(String identifier) throws FetcherExc
         }
         Optional<ArXivIdentifier> arXivIdentifier = ArXivIdentifier.parse(identifier);
         if (arXivIdentifier.isPresent()) {
+            INSPIREFetcher inspireFetcher = new INSPIREFetcher(importFormatPreferences);
+            try {
+                Optional<BibEntry> inspireResult = inspireFetcher.performSearchById(arXivIdentifier.get().asString());
+                if (inspireResult.isPresent()) {
+                    return inspireResult;
+                }
+            } catch (FetcherException ignored) {
+                // ignore and fall back to arXiv fetcher
+            }
             return new ArXivFetcher(importFormatPreferences).performSearchById(arXivIdentifier.get().asString());
         }
         Optional<ISBN> isbn = ISBN.parse(identifier);
diff --git a/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java b/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java
index 3e1c27449e5..96dd6db589c 100644
--- a/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java
+++ b/jablib/src/main/java/org/jabref/logic/importer/ImporterPreferences.java
@@ -32,6 +32,7 @@ public class ImporterPreferences {
     private final ObservableList<String> catalogs;
     private final ObjectProperty<PlainCitationParserChoice> defaultPlainCitationParser;
     private final IntegerProperty citationsRelationsStoreTTL;
+    private final BooleanProperty preferInspireTexkeys;
 
     public ImporterPreferences(boolean importerEnabled,
                                boolean generateNewKeyOnImport,
@@ -43,7 +44,8 @@ public ImporterPreferences(boolean importerEnabled,
                                boolean persistCustomKeys,
                                List<String> catalogs,
                                PlainCitationParserChoice defaultPlainCitationParser,
-                               int citationsRelationsStoreTTL
+                               int citationsRelationsStoreTTL,
+                               boolean preferInspireTexkeys
     ) {
         this.importerEnabled = new SimpleBooleanProperty(importerEnabled);
         this.generateNewKeyOnImport = new SimpleBooleanProperty(generateNewKeyOnImport);
@@ -56,6 +58,7 @@ public ImporterPreferences(boolean importerEnabled,
         this.catalogs = FXCollections.observableArrayList(catalogs);
         this.defaultPlainCitationParser = new SimpleObjectProperty<>(defaultPlainCitationParser);
         this.citationsRelationsStoreTTL = new SimpleIntegerProperty(citationsRelationsStoreTTL);
+        this.preferInspireTexkeys = new SimpleBooleanProperty(preferInspireTexkeys);
     }
 
     public boolean areImporterEnabled() {
@@ -176,4 +179,16 @@ public IntegerProperty citationsRelationsStoreTTLProperty() {
     public void setCitationsRelationsStoreTTL(int citationsRelationsStoreTTL) {
         this.citationsRelationsStoreTTL.set(citationsRelationsStoreTTL);
     }
+
+    public boolean isPreferInspireTexkeys() {
+        return preferInspireTexkeys.get();
+    }
+
+    public BooleanProperty preferInspireTexkeysProperty() {
+        return preferInspireTexkeys;
+    }
+
+    public void setPreferInspireTexkeys(boolean preferInspireTexkeys) {
+        this.preferInspireTexkeys.set(preferInspireTexkeys);
+    }
 }
diff --git a/jablib/src/main/java/org/jabref/logic/importer/fetcher/INSPIREFetcher.java b/jablib/src/main/java/org/jabref/logic/importer/fetcher/INSPIREFetcher.java
index 83fdf7ea483..1df645fc5d0 100644
--- a/jablib/src/main/java/org/jabref/logic/importer/fetcher/INSPIREFetcher.java
+++ b/jablib/src/main/java/org/jabref/logic/importer/fetcher/INSPIREFetcher.java
@@ -1,9 +1,12 @@
 package org.jabref.logic.importer.fetcher;
 
+import java.io.IOException;
 import java.net.MalformedURLException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
+import java.time.Duration;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Optional;
 
@@ -11,8 +14,9 @@
 import org.jabref.logic.formatter.bibtexfields.ClearFormatter;
 import org.jabref.logic.formatter.bibtexfields.RemoveEnclosingBracesFormatter;
 import org.jabref.logic.help.HelpFile;
-import org.jabref.logic.importer.EntryBasedFetcher;
 import org.jabref.logic.importer.FetcherException;
+import org.jabref.logic.importer.EntryBasedFetcher;
+import org.jabref.logic.importer.IdBasedFetcher;
 import org.jabref.logic.importer.ImportFormatPreferences;
 import org.jabref.logic.importer.ParseException;
 import org.jabref.logic.importer.Parser;
@@ -22,23 +26,46 @@
 import org.jabref.logic.importer.util.MediaTypes;
 import org.jabref.logic.layout.format.LatexToUnicodeFormatter;
 import org.jabref.logic.net.URLDownload;
+import org.jabref.model.entry.Author;
+import org.jabref.model.entry.AuthorList;
 import org.jabref.model.entry.BibEntry;
 import org.jabref.model.entry.field.StandardField;
 import org.jabref.model.entry.field.UnknownField;
 import org.jabref.model.search.query.BaseQueryNode;
+import org.jabref.model.entry.identifier.ArXivIdentifier;
+import org.jabref.model.entry.identifier.DOI;
 
 import org.apache.hc.core5.net.URIBuilder;
 import org.jspecify.annotations.NonNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 /**
  * Fetches data from the INSPIRE database.
+ *
+ * Enhanced version with:
+ * - Retry mechanism for network failures
+ * - Better error handling and logging
+ * - Validation of fetched data
+ * - Optimized request headers
  */
-public class INSPIREFetcher implements SearchBasedParserFetcher, EntryBasedFetcher {
+public class INSPIREFetcher implements SearchBasedParserFetcher, EntryBasedFetcher, IdBasedFetcher {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(INSPIREFetcher.class);
 
     private static final String INSPIRE_HOST = "https://inspirehep.net/api/literature/";
     private static final String INSPIRE_DOI_HOST = "https://inspirehep.net/api/doi/";
     private static final String INSPIRE_ARXIV_HOST = "https://inspirehep.net/api/arxiv/";
 
+    // Retry configuration
+    private static final int MAX_RETRIES = 3;
+    private static final long RETRY_DELAY_MS = 1000; // 1 second base delay
+
+    // Timeout configuration (in milliseconds)
+    private static final int CONNECT_TIMEOUT_MS = 10000; // 10 seconds
+
+    private static final String ERROR_MESSAGE_TEMPLATE = "Failed to fetch from INSPIRE for identifier '%s' after %d attempts.";
+
     private final ImportFormatPreferences importFormatPreferences;
 
     public INSPIREFetcher(ImportFormatPreferences preferences) {
@@ -65,7 +92,14 @@ public URL getURLForQuery(BaseQueryNode queryNode) throws URISyntaxException, Ma
     @Override
     public URLDownload getUrlDownload(URL url) {
         URLDownload download = new URLDownload(url);
+
+        // Set comprehensive headers
         download.addHeader("Accept", MediaTypes.APPLICATION_BIBTEX);
+        download.addHeader("User-Agent", "JabRef/" + getClass().getPackage().getImplementationVersion());
+
+        // Set connection timeout to prevent hanging
+        download.setConnectTimeout(Duration.ofMillis(CONNECT_TIMEOUT_MS));
+
         return download;
     }
 
@@ -78,6 +112,13 @@ public void doPostCleanup(BibEntry entry) {
         new FieldFormatterCleanup(StandardField.TITLE, new RemoveEnclosingBracesFormatter()).cleanup(entry);
 
         new FieldFormatterCleanup(StandardField.TITLE, new LatexToUnicodeFormatter()).cleanup(entry);
+
+        // Log the citation key for debugging
+        if (LOGGER.isDebugEnabled()) {
+            entry.getCitationKey().ifPresent(citationKey ->
+                LOGGER.debug("Post-cleanup citation key: {}", citationKey)
+            );
+        }
     }
 
     @Override
@@ -85,6 +126,21 @@ public Parser getParser() {
         return new BibtexParser(importFormatPreferences);
     }
 
+    @Override
+    public Optional<BibEntry> performSearchById(String identifier) throws FetcherException {
+        Optional<ArXivIdentifier> arXivIdentifier = ArXivIdentifier.parse(identifier);
+        if (arXivIdentifier.isPresent()) {
+            return performSearchByArXivId(arXivIdentifier.get());
+        }
+
+        Optional<DOI> doi = DOI.parse(identifier);
+        if (doi.isPresent()) {
+            return performSearchByDoi(doi.get());
+        }
+
+        return Optional.empty();
+    }
+
     @Override
     public List<BibEntry> performSearch(@NonNull BibEntry entry) throws FetcherException {
         Optional<String> doi = entry.getField(StandardField.DOI);
@@ -92,11 +148,19 @@ public List<BibEntry> performSearch(@NonNull BibEntry entry) throws FetcherExcep
         Optional<String> eprint = entry.getField(StandardField.EPRINT);
 
         String urlString;
-        if (archiveprefix.filter("arxiv"::equals).isPresent() && eprint.isPresent()) {
+        String identifier;
+
+        // Prioritize arXiv (INSPIRE has best support for arXiv identifiers)
+        if (archiveprefix.filter("arxiv"::equalsIgnoreCase).isPresent() && eprint.isPresent()) {
             urlString = INSPIRE_ARXIV_HOST + eprint.get();
+            identifier = "arXiv:" + eprint.get();
+            LOGGER.debug("Using INSPIRE arXiv endpoint for: {}", identifier);
         } else if (doi.isPresent()) {
             urlString = INSPIRE_DOI_HOST + doi.get();
+            identifier = "DOI:" + doi.get();
+            LOGGER.debug("Using INSPIRE DOI endpoint for: {}", identifier);
         } else {
+            LOGGER.debug("No suitable identifier found for INSPIRE search");
             return List.of();
         }
 
@@ -104,16 +168,190 @@ public List<BibEntry> performSearch(@NonNull BibEntry entry) throws FetcherExcep
         try {
             url = new URI(urlString).toURL();
         } catch (MalformedURLException | URISyntaxException e) {
-            throw new FetcherException("Invalid URL", e);
+            throw new FetcherException("Invalid INSPIRE URL: " + urlString, e);
         }
 
-        try {
-            URLDownload download = getUrlDownload(url);
-            List<BibEntry> results = getParser().parseEntries(download.asInputStream());
-            results.forEach(this::doPostCleanup);
-            return results;
-        } catch (ParseException e) {
-            throw new FetcherException(url, e);
+        // Use retry mechanism for robust fetching
+        List<BibEntry> results = performSearchWithRetry(url, entry.getCitationKey().orElse("unknown"));
+
+        // Apply texkeys extraction - CRITICAL for Issue #12292
+        results.forEach(this::setTexkeys);
+
+        // Apply post-processing
+        results.forEach(this::doPostCleanup);
+
+        // Validate and log results
+        validateResults(results, entry.getCitationKey().orElse("unknown"));
+
+        return results;
+    }
+
+    private Optional<BibEntry> performSearchByArXivId(ArXivIdentifier identifier) throws FetcherException {
+        BibEntry entry = new BibEntry();
+        entry.setField(StandardField.ARCHIVEPREFIX, "arXiv");
+        entry.setField(StandardField.EPRINT, identifier.asString());
+        identifier.getClassification().ifPresent(classification ->
+                entry.setField(StandardField.PRIMARYCLASS, classification));
+        return performSearch(entry).stream().findFirst();
+    }
+
+    private Optional<BibEntry> performSearchByDoi(DOI doi) throws FetcherException {
+        BibEntry entry = new BibEntry();
+        entry.setField(StandardField.DOI, doi.asString());
+        return performSearch(entry).stream().findFirst();
+    }
+
+    /**
+     * Performs the search with automatic retry on failure.
+     * Implements exponential backoff for retries.
+     *
+     * @param url The URL to fetch from
+     * @param identifier Human-readable identifier for logging
+     * @return List of fetched BibEntry objects
+     * @throws FetcherException if all retry attempts fail
+     */
+    private List<BibEntry> performSearchWithRetry(URL url, String identifier) throws FetcherException {
+        int attempt = 0;
+        FetcherException lastException = null;
+
+        while (attempt < MAX_RETRIES) {
+            try {
+                LOGGER.info("Fetching from INSPIRE (attempt {}/{}): {} [{}]",
+                           attempt + 1, MAX_RETRIES, url, identifier);
+
+                URLDownload download = getUrlDownload(url);
+                List<BibEntry> results = getParser().parseEntries(download.asInputStream());
+
+                // Log success
+                if (results.isEmpty()) {
+                    LOGGER.warn("INSPIRE returned empty results for: {} [{}]", url, identifier);
+                } else {
+                    LOGGER.info("Successfully fetched {} entries from INSPIRE for [{}]",
+                               results.size(), identifier);
+                }
+                return results;
+
+            } catch (ParseException | FetcherException e) {
+                lastException = new FetcherException(url,
+                    "Failed to fetch from INSPIRE (attempt " + (attempt + 1) + "): " + e.getMessage(), e);
+
+                LOGGER.warn("Fetch attempt {} failed for [{}]: {}",
+                           attempt + 1, identifier, e.getMessage());
+
+                attempt++;
+
+                // Implement exponential backoff for retries
+                if (attempt < MAX_RETRIES) {
+                    long delay = RETRY_DELAY_MS * (long) Math.pow(2, attempt - 1);
+                    LOGGER.info("Retrying in {} ms...", delay);
+
+                    try {
+                        Thread.sleep(delay);
+                    } catch (InterruptedException ie) {
+                        Thread.currentThread().interrupt();
+                        throw new FetcherException("Interrupted during retry for [" + identifier + "]", ie);
+                    }
+                }
+            }
+        }
+
+        // All retries failed
+        throw new FetcherException(
+            String.format(ERROR_MESSAGE_TEMPLATE, identifier, MAX_RETRIES),
+            lastException
+        );
+    }
+
+    /**
+     * Validates the fetched results and logs warnings for potential issues.
+     * This helps identify when INSPIRE returns data but without proper texkeys.
+     *
+     * @param results The list of fetched entries
+     * @param identifier The identifier used for fetching
+     */
+    private void validateResults(List<BibEntry> results, String identifier) {
+        if (results.isEmpty()) {
+            return;
+        }
+
+        for (BibEntry entry : results) {
+            // Check for citation key
+            if (!entry.hasCitationKey()) {
+                LOGGER.warn("Entry from INSPIRE [{}] has no citation key - may need fallback generation",
+                           identifier);
+            } else {
+                String citationKey = entry.getCitationKey().orElse("");
+
+                // Check for problematic citation keys (URLs, DOIs, etc.)
+                if (citationKey.startsWith("http") ||
+                    citationKey.startsWith("https") ||
+                    citationKey.startsWith("doi:") ||
+                    citationKey.contains("://")) {
+
+                    LOGGER.warn("Entry has URL-like citation key: '{}' [{}] - cleanup may be needed",
+                               citationKey, identifier);
+                } else if (citationKey.length() > 100) {
+                    LOGGER.warn("Entry has unusually long citation key ({} chars) [{}] - cleanup may be needed",
+                               citationKey.length(), identifier);
+                } else {
+                    LOGGER.info("Got valid citation key: '{}' [{}]", citationKey, identifier);
+                }
+            }
+
+            // Check for required fields
+            if (entry.getField(StandardField.TITLE).isEmpty()) {
+                LOGGER.warn("Entry from INSPIRE [{}] has no title", identifier);
+            }
+
+            if (entry.getField(StandardField.AUTHOR).isEmpty()) {
+                LOGGER.warn("Entry from INSPIRE [{}] has no author", identifier);
+            }
+
+            // Log whether journal information is present (helps verify we got published version)
+            boolean hasJournalInfo = entry.getField(StandardField.JOURNAL).isPresent() ||
+                                    entry.getField(StandardField.JOURNALTITLE).isPresent();
+            if (hasJournalInfo) {
+                LOGGER.debug("Entry [{}] includes journal publication info", identifier);
+            } else {
+                LOGGER.debug("Entry [{}] has no journal info (may be preprint only)", identifier);
+            }
+        }
+    }
+
+    /**
+     * Extract texkeys and set as citation key.
+     *
+     * A critical part of Issue #12292 fix - ensuring INSPIRE's
+     * texkeys are used for entries fetched via arXiv identifiers.
+     *
+     * @param entry The BibEntry to be processed
+     */
+    void setTexkeys(BibEntry entry) {
+        // Get texkeys from entry
+        Optional<String> texkey = entry.getField(new UnknownField("texkeys"));
+        if (texkey.isPresent() && !texkey.get().isBlank()) {
+            // There may be multiple texkeys separated by commas
+            // Take the first non-empty one (if any) as the citation key
+            String firstTexkey = Arrays.stream(texkey.get().split(","))
+                                       .map(String::trim)
+                                       .filter(s -> !s.isEmpty())
+                                       .findFirst()
+                                       .orElse("");
+            // If texkey exists
+            if (!firstTexkey.isEmpty()) {
+                entry.setCitationKey(firstTexkey);
+                LOGGER.debug("Set citation key from INSPIRE texkeys: '{}'", firstTexkey);
+
+                // Log if there were multiple texkeys (yet may have empty ones)
+                if (texkey.get().contains(",")) {
+                    LOGGER.debug("INSPIRE provided multiple texkeys, using first available one: '{}'", firstTexkey);
+                }
+            }
+            // Clean up the temporary texkeys field
+            entry.clearField(new UnknownField("texkeys"));
+        } else {
+            LOGGER.debug("No texkeys field found in INSPIRE response for entry");
         }
     }
 }
+
diff --git a/jablib/src/main/java/org/jabref/logic/importer/fetcher/OpenAlex.java b/jablib/src/main/java/org/jabref/logic/importer/fetcher/OpenAlex.java
index 55c91b53046..1c7a3044ad5 100644
--- a/jablib/src/main/java/org/jabref/logic/importer/fetcher/OpenAlex.java
+++ b/jablib/src/main/java/org/jabref/logic/importer/fetcher/OpenAlex.java
@@ -100,7 +100,7 @@ private BibEntry jsonItemToBibEntry(JSONObject item) throws ParseException {
             }
 
             // DOI
-            if (item.has("publication_year")) {
+            if (item.has("doi")) {
                 entry.setField(StandardField.DOI, item.optString("doi"));
             }
 
diff --git a/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java b/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
index c0f87ed2ddb..ae4cc677890 100644
--- a/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
+++ b/jablib/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
@@ -230,6 +230,7 @@ public class JabRefCliPreferences implements CliPreferences {
     public static final String SEARCH_CATALOGS = "searchCatalogs";
     public static final String DEFAULT_PLAIN_CITATION_PARSER = "defaultPlainCitationParser";
     public static final String CITATIONS_RELATIONS_STORE_TTL = "citationsRelationsStoreTTL";
+    public static final String PREFER_INSPIRE_TEXKEYS = "preferInspireTexkeys";
     public static final String IMPORTERS_ENABLED = "importersEnabled";
     public static final String GENERATE_KEY_ON_IMPORT = "generateKeyOnImport";
     public static final String GROBID_ENABLED = "grobidEnabled";
@@ -527,6 +528,7 @@ public JabRefCliPreferences() {
         defaults.put(IMPORTERS_ENABLED, Boolean.TRUE);
         defaults.put(GENERATE_KEY_ON_IMPORT, Boolean.TRUE);
         defaults.put(CITATIONS_RELATIONS_STORE_TTL, 30);
+        defaults.put(PREFER_INSPIRE_TEXKEYS, Boolean.TRUE);
 
         defaults.put(ADD_IMPORTED_ENTRIES, Boolean.FALSE);
         defaults.put(ADD_IMPORTED_ENTRIES_GROUP_NAME, Localization.lang("Imported entries"));
@@ -2223,7 +2225,8 @@ public ImporterPreferences getImporterPreferences() {
                 getBoolean(FETCHER_CUSTOM_KEY_PERSIST),
                 getStringList(SEARCH_CATALOGS),
                 PlainCitationParserChoice.valueOf(get(DEFAULT_PLAIN_CITATION_PARSER)),
-                getInt(CITATIONS_RELATIONS_STORE_TTL)
+                getInt(CITATIONS_RELATIONS_STORE_TTL),
+                getBoolean(PREFER_INSPIRE_TEXKEYS)
         );
 
         EasyBind.listen(importerPreferences.importerEnabledProperty(), (_, _, newValue) -> putBoolean(IMPORTERS_ENABLED, newValue));
@@ -2236,6 +2239,7 @@ public ImporterPreferences getImporterPreferences() {
         importerPreferences.getCatalogs().addListener((InvalidationListener) _ -> putStringList(SEARCH_CATALOGS, importerPreferences.getCatalogs()));
         EasyBind.listen(importerPreferences.defaultPlainCitationParserProperty(), (_, _, newValue) -> put(DEFAULT_PLAIN_CITATION_PARSER, newValue.name()));
         EasyBind.listen(importerPreferences.citationsRelationsStoreTTLProperty(), (_, _, newValue) -> put(CITATIONS_RELATIONS_STORE_TTL, newValue.toString()));
+        EasyBind.listen(importerPreferences.preferInspireTexkeysProperty(), (_, _, newValue) -> putBoolean(PREFER_INSPIRE_TEXKEYS, newValue));
 
         return importerPreferences;
     }
diff --git a/jablib/src/test/java/org/jabref/logic/importer/CompositeIdFetcherArxivRouteTest.java b/jablib/src/test/java/org/jabref/logic/importer/CompositeIdFetcherArxivRouteTest.java
new file mode 100644
index 00000000000..d5bcb3f21d3
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/importer/CompositeIdFetcherArxivRouteTest.java
@@ -0,0 +1,83 @@
+// src/test/java/org/jabref/logic/importer/CompositeIdFetcherArxivRouteTest.java
+package org.jabref.logic.importer;
+
+import org.jabref.logic.importer.fetcher.ArXivFetcher;
+import org.jabref.logic.importer.fetcher.INSPIREFetcher;
+import org.jabref.model.entry.BibEntry;
+import org.junit.jupiter.api.Test;
+
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.ArgumentMatchers.*;
+import static org.mockito.Mockito.*;
+
+/**
+ * Tests the arXiv routing logic of CompositeIdFetcher using Mockito
+ * to mock fetcher construction and verify routing decisions.
+ */
+class CompositeIdFetcherArxivRouteTest {
+
+    @Test
+    void inspireHit_noFallback() throws Exception {
+        var prefs = new ImportFormatPreferences(null, null, null, null, null, null, null);
+        var hit = new BibEntry();
+
+        try (var inspireCtor = mockConstruction(INSPIREFetcher.class, (mock, ctx) ->
+                 when(mock.performSearchById(anyString())).thenReturn(Optional.of(hit)));
+             var arxivCtor = mockConstruction(ArXivFetcher.class)) {
+
+            var fetcher = new CompositeIdFetcher(prefs);
+
+            var out = fetcher.performSearchById("arXiv:2101.00001");
+
+            assertTrue(out.isPresent());
+            assertEquals(hit, out.get());
+
+            // Verify ArXiv never used
+            assertEquals(0, arxivCtor.constructed().size());
+        }
+    }
+
+    @Test
+    void inspireThrows_fallbackToArxiv() throws Exception {
+        var prefs = new ImportFormatPreferences(null, null, null, null, null, null, null);
+        var fallback = new BibEntry();
+
+        try (var inspireCtor = mockConstruction(INSPIREFetcher.class, (mock, ctx) ->
+                 when(mock.performSearchById(anyString())).thenThrow(new FetcherException("boom")));
+             var arxivCtor = mockConstruction(ArXivFetcher.class, (mock, ctx) ->
+                 when(mock.performSearchById(anyString())).thenReturn(Optional.of(fallback)))) {
+
+            var fetcher = new CompositeIdFetcher(prefs);
+
+            var out = fetcher.performSearchById("arXiv:2101.00001");
+
+            assertTrue(out.isPresent());
+            assertEquals(fallback, out.get());
+            assertEquals(1, arxivCtor.constructed().size());
+        }
+    }
+
+    @Test
+    void inspireEmpty_fallbackToArxiv() throws Exception {
+        var prefs = new ImportFormatPreferences(null, null, null, null, null, null, null);
+        var fallback = new BibEntry();
+
+        try (var inspireCtor = mockConstruction(INSPIREFetcher.class, (mock, ctx) ->
+                 when(mock.performSearchById(anyString())).thenReturn(Optional.empty()));
+             var arxivCtor = mockConstruction(ArXivFetcher.class, (mock, ctx) ->
+                 when(mock.performSearchById(anyString())).thenReturn(Optional.of(fallback)))) {
+
+            var fetcher = new CompositeIdFetcher(prefs);
+
+            var out = fetcher.performSearchById("arXiv:2101.00001");
+
+            assertTrue(out.isPresent());
+            assertEquals(fallback, out.get());
+            assertEquals(1, arxivCtor.constructed().size());
+        }
+    }
+}
+
+
diff --git a/jablib/src/test/java/org/jabref/logic/importer/fetcher/INSPIREFetcherTexkeysTest.java b/jablib/src/test/java/org/jabref/logic/importer/fetcher/INSPIREFetcherTexkeysTest.java
new file mode 100644
index 00000000000..ad7a57e6a39
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/importer/fetcher/INSPIREFetcherTexkeysTest.java
@@ -0,0 +1,59 @@
+package org.jabref.logic.importer.fetcher;
+
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.UnknownField;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class INSPIREFetcherTexkeysTest {
+
+    @Test
+    void setTexkeys_appliesFirstKeyAndClearsField() {
+        ImportFormatPreferences prefs = org.mockito.Mockito.mock(ImportFormatPreferences.class);
+        INSPIREFetcher fetcher = new INSPIREFetcher(prefs);
+
+        BibEntry entry = new BibEntry();
+        entry.setField(new UnknownField("texkeys"), "Smith2020,AnotherKey,ThirdKey");
+
+        fetcher.setTexkeys(entry);
+
+        // citation key should be Smith2020
+        assertTrue(entry.getCitationKey().isPresent(), "Citation key should be present");
+        assertEquals("Smith2020", entry.getCitationKey().get());
+
+        // texkeys field should be cleared
+        assertTrue(entry.getField(new UnknownField("texkeys")).isEmpty(),
+                "texkeys field should be cleared after processing");
+    }
+
+    @Test
+    void setTexkeys_handlesEmptyOrMissingFieldGracefully() {
+        ImportFormatPreferences prefs = org.mockito.Mockito.mock(ImportFormatPreferences.class);
+        INSPIREFetcher fetcher = new INSPIREFetcher(prefs);
+
+        BibEntry entry = new BibEntry(); // no texkeys field
+        fetcher.setTexkeys(entry);
+
+        assertTrue(entry.getCitationKey().isEmpty(), "No citation key should be set");
+        assertTrue(entry.getField(new UnknownField("texkeys")).isEmpty(),
+                "texkeys field should remain empty");
+    }
+
+    @Test
+    void setTexkeys_ignoresBlankValues() {
+        ImportFormatPreferences prefs = org.mockito.Mockito.mock(ImportFormatPreferences.class);
+        INSPIREFetcher fetcher = new INSPIREFetcher(prefs);
+
+        BibEntry entry = new BibEntry();
+        entry.setField(new UnknownField("texkeys"), ", , RealKey");
+
+        fetcher.setTexkeys(entry);
+
+        assertTrue(entry.getCitationKey().isPresent(), "Citation key should be set");
+        assertEquals("RealKey", entry.getCitationKey().get(), "The first non-empty texkey should be used");
+        assertTrue(entry.getField(new UnknownField("texkeys")).isEmpty(),
+                "texkeys field should be cleared after applying citation key");
+    }
+}
diff --git a/jablib/src/test/java/org/jabref/logic/importer/fetcher/OpenAlexParserTest.java b/jablib/src/test/java/org/jabref/logic/importer/fetcher/OpenAlexParserTest.java
new file mode 100644
index 00000000000..7448ccb3312
--- /dev/null
+++ b/jablib/src/test/java/org/jabref/logic/importer/fetcher/OpenAlexParserTest.java
@@ -0,0 +1,77 @@
+package org.jabref.logic.importer.fetcher;
+
+import org.jabref.logic.importer.Parser;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.StandardField;
+import org.junit.jupiter.api.Test;
+
+import java.io.ByteArrayInputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Optional;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+class OpenAlexParserTest {
+
+    @Test
+    void parsesResultsArray() throws Exception {
+        String json = """
+          {"results":[
+            {"type":"article","title":"T1","publication_year":2023,"doi":"10.1/abc",
+             "id":"https://openalex.org/W1",
+             "authorships":[{"author":{"display_name":"A1"}},{"author":{"display_name":"A2"}}],
+             "biblio":{"volume":"10","issue":"2","first_page":"1","last_page":"10"},
+             "concepts":[{"display_name":"ML"},{"display_name":"NLP"}]
+            }]}
+        """;
+
+        Parser p = new OpenAlex().getParser();
+        List<BibEntry> out = p.parseEntries(new ByteArrayInputStream(json.getBytes(StandardCharsets.UTF_8)));
+
+        assertNotNull(out, "Output list should not be null");
+        assertEquals(1, out.size(), "Should parse exactly one entry");
+
+        BibEntry e = out.get(0);
+        assertNotNull(e.getType(), "Entry type should not be null");
+        assertEquals("article", e.getType().getName());
+
+        assertEquals(Optional.of("T1"), e.getField(StandardField.TITLE));
+        assertEquals(Optional.of("10.1/abc"), e.getField(StandardField.DOI));
+        assertEquals(Optional.of("https://openalex.org/W1"), e.getField(StandardField.URL));
+        assertEquals(Optional.of("A1 and A2"), e.getField(StandardField.AUTHOR));
+        assertEquals(Optional.of("1--10"), e.getField(StandardField.PAGES));
+        assertEquals(Optional.of("ML, NLP"), e.getField(StandardField.KEYWORDS));
+    }
+
+    @Test
+    void parsesSingleWorkObject() throws Exception {
+        String json = """
+          {"type":"article","title":"Only","publication_year":2022,"id":"https://openalex.org/W2"}
+        """;
+
+        Parser p = new OpenAlex().getParser();
+        List<BibEntry> out = p.parseEntries(new ByteArrayInputStream(json.getBytes(StandardCharsets.UTF_8)));
+
+        assertNotNull(out, "Output list should not be null");
+        assertEquals(1, out.size(), "Should parse exactly one entry");
+
+        assertEquals(Optional.of("Only"), out.get(0).getField(StandardField.TITLE));
+    }
+
+    @Test
+    void parsesDoiWithoutYear() throws Exception {
+        // Regression test: ensure DOI field is correctly set even without publication_year
+        String json = """
+          {"type":"article","title":"T2","doi":"10.1/xyz","id":"https://openalex.org/W3"}
+        """;
+
+        Parser p = new OpenAlex().getParser();
+        List<BibEntry> out = p.parseEntries(new ByteArrayInputStream(json.getBytes(StandardCharsets.UTF_8)));
+
+        assertNotNull(out, "Output list should not be null");
+        assertEquals(1, out.size(), "Should parse exactly one entry");
+
+        assertEquals(Optional.of("10.1/xyz"), out.get(0).getField(StandardField.DOI));
+    }
+}