diff --git a/src/main/java/org/jabref/gui/actions/StandardActions.java b/src/main/java/org/jabref/gui/actions/StandardActions.java
index 3f2f8b8ca15..4d99f46f019 100644
--- a/src/main/java/org/jabref/gui/actions/StandardActions.java
+++ b/src/main/java/org/jabref/gui/actions/StandardActions.java
@@ -209,6 +209,10 @@ public enum StandardActions implements Action {
     GROUP_SUBGROUP_RENAME(Localization.lang("Rename subgroup"), KeyBinding.GROUP_SUBGROUP_RENAME),
     GROUP_ENTRIES_REMOVE(Localization.lang("Remove selected entries from this group")),
 
+    GIT(Localization.lang("Git")),
+    GIT_PULL(Localization.lang("Git Pull")),
+    GIT_PUSH(Localization.lang("Git Push")),
+
     CLEAR_EMBEDDINGS_CACHE(Localization.lang("Clear embeddings cache"));
 
     private String text;
diff --git a/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java b/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java
index 10487ead6ad..b29838b5c13 100644
--- a/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java
+++ b/src/main/java/org/jabref/gui/exporter/SaveDatabaseAction.java
@@ -32,6 +32,7 @@
 import org.jabref.logic.exporter.BibtexDatabaseWriter;
 import org.jabref.logic.exporter.SaveException;
 import org.jabref.logic.exporter.SelfContainedSaveConfiguration;
+import org.jabref.logic.git.GitClientHandler;
 import org.jabref.logic.l10n.Encodings;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.logic.shared.DatabaseLocation;
@@ -237,6 +238,10 @@ private boolean save(Path targetPath, SaveDatabaseMode mode) {
             if (success) {
                 libraryTab.getUndoManager().markUnchanged();
                 libraryTab.resetChangedProperties();
+                new GitClientHandler(targetPath.getParent(),
+                        dialogService,
+                        preferences.getGitPreferences())
+                        .postSaveDatabaseAction();
             }
             dialogService.notify(Localization.lang("Library saved"));
             return success;
diff --git a/src/main/java/org/jabref/gui/frame/MainMenu.java b/src/main/java/org/jabref/gui/frame/MainMenu.java
index e119bf449fd..c3f72d59e2c 100644
--- a/src/main/java/org/jabref/gui/frame/MainMenu.java
+++ b/src/main/java/org/jabref/gui/frame/MainMenu.java
@@ -61,6 +61,8 @@
 import org.jabref.gui.push.PushToApplicationCommand;
 import org.jabref.gui.search.RebuildFulltextSearchIndexAction;
 import org.jabref.gui.shared.ConnectToSharedDatabaseCommand;
+import org.jabref.gui.shared.GitPullAction;
+import org.jabref.gui.shared.GitPushAction;
 import org.jabref.gui.shared.PullChangesFromSharedAction;
 import org.jabref.gui.sidepane.SidePane;
 import org.jabref.gui.sidepane.SidePaneType;
@@ -160,6 +162,12 @@ private void createMenu() {
 
                 new SeparatorMenuItem(),
 
+               factory.createSubMenu(StandardActions.GIT,
+                       factory.createMenuItem(StandardActions.GIT_PUSH, new GitPushAction(preferences, dialogService, stateManager)),
+                       factory.createMenuItem(StandardActions.GIT_PULL, new GitPullAction(preferences, dialogService, stateManager))),
+
+                new SeparatorMenuItem(),
+
                 factory.createSubMenu(StandardActions.IMPORT,
                         factory.createMenuItem(StandardActions.IMPORT_INTO_CURRENT_LIBRARY, new ImportCommand(frame, ImportCommand.ImportMethod.TO_EXISTING, preferences, stateManager, fileUpdateMonitor, taskExecutor, dialogService)),
                         factory.createMenuItem(StandardActions.IMPORT_INTO_NEW_LIBRARY, new ImportCommand(frame, ImportCommand.ImportMethod.AS_NEW, preferences, stateManager, fileUpdateMonitor, taskExecutor, dialogService))),
@@ -407,3 +415,5 @@ private Menu createSendSubMenu(ActionFactory factory,
         return sendMenu;
     }
 }
+
+
diff --git a/src/main/java/org/jabref/gui/importer/actions/CheckForVersionControlAction.java b/src/main/java/org/jabref/gui/importer/actions/CheckForVersionControlAction.java
new file mode 100644
index 00000000000..fb80aae56a6
--- /dev/null
+++ b/src/main/java/org/jabref/gui/importer/actions/CheckForVersionControlAction.java
@@ -0,0 +1,46 @@
+package org.jabref.gui.importer.actions;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Optional;
+
+import org.jabref.gui.DialogService;
+import org.jabref.logic.git.GitClientHandler;
+import org.jabref.logic.importer.ParserResult;
+import org.jabref.logic.preferences.CliPreferences;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * This action checks whether this BIB file is contained in a Git repository. If so,
+ * then the file is tagged as "versioned" in BibDatabaseContext and a git pull is
+ * attempted.
+ */
+public class CheckForVersionControlAction implements GUIPostOpenAction {
+    private static final Logger LOGGER = LoggerFactory.getLogger(CheckForVersionControlAction.class);
+    private GitClientHandler gitClientHandler;
+
+    @Override
+    public boolean isActionNecessary(ParserResult parserResult, DialogService dialogService, CliPreferences preferences) {
+        Optional<Path> path = parserResult.getDatabaseContext().getDatabasePath();
+        if (path.isEmpty()) {
+            return false;
+        }
+        this.gitClientHandler = new GitClientHandler(path.get(),
+                dialogService,
+                preferences.getGitPreferences());
+        return gitClientHandler.isGitRepository();
+    }
+
+    @Override
+    public void performAction(ParserResult parserResult, DialogService dialogService, CliPreferences preferencesService) {
+        parserResult.getDatabaseContext().setVersioned(true);
+
+        try {
+            this.gitClientHandler.pullOnCurrentBranch();
+        } catch (IOException e) {
+            LOGGER.error("Failed to pull.", e);
+        }
+    }
+}
diff --git a/src/main/java/org/jabref/gui/preferences/general/GeneralTab.fxml b/src/main/java/org/jabref/gui/preferences/general/GeneralTab.fxml
index 924cd2a7504..161197cd6b3 100644
--- a/src/main/java/org/jabref/gui/preferences/general/GeneralTab.fxml
+++ b/src/main/java/org/jabref/gui/preferences/general/GeneralTab.fxml
@@ -120,4 +120,19 @@
             <Insets top="-4.0"/>
         </VBox.margin>
     </HBox>
+
+    <Label styleClass="sectionHeader" text="%Git"/>
+    <HBox spacing="10">
+        <Label text="Git Username:"/>
+        <TextField fx:id="gitHubUsernameField" promptText="Enter your username here"/>
+    </HBox>
+
+    <HBox spacing="10">
+        <Label text="Git Personal Access Token:"/>
+        <TextField fx:id="gitHubPasskeyField" promptText="Enter your PAT here"/>
+    </HBox>
+    <HBox alignment="CENTER_LEFT" spacing="4.0">
+        <CheckBox fx:id="autoPushCheckbox" text="Auto Push"/>
+        <ComboBox fx:id="autoPushModeComboBox"/>
+    </HBox>
 </fx:root>
diff --git a/src/main/java/org/jabref/gui/preferences/general/GeneralTab.java b/src/main/java/org/jabref/gui/preferences/general/GeneralTab.java
index 73e23068dc0..d2a5bfb77cb 100644
--- a/src/main/java/org/jabref/gui/preferences/general/GeneralTab.java
+++ b/src/main/java/org/jabref/gui/preferences/general/GeneralTab.java
@@ -24,6 +24,7 @@
 import org.jabref.logic.help.HelpFile;
 import org.jabref.logic.l10n.Language;
 import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.preferences.AutoPushMode;
 import org.jabref.model.database.BibDatabaseMode;
 import org.jabref.model.entry.BibEntryTypesManager;
 import org.jabref.model.util.FileUpdateMonitor;
@@ -53,6 +54,10 @@ public class GeneralTab extends AbstractPreferenceTabView<GeneralTabViewModel> i
     @FXML private CheckBox alwaysReformatBib;
     @FXML private CheckBox autosaveLocalLibraries;
     @FXML private Button autosaveLocalLibrariesHelp;
+    @FXML private TextField gitHubUsernameField;
+    @FXML private TextField gitHubPasskeyField;
+    @FXML private CheckBox autoPushCheckbox;
+    @FXML private ComboBox<AutoPushMode> autoPushModeComboBox;
     @FXML private CheckBox createBackup;
     @FXML private TextField backupDirectory;
     @FXML private CheckBox remoteServer;
@@ -132,6 +137,14 @@ public void initialize() {
 
         alwaysReformatBib.selectedProperty().bindBidirectional(viewModel.alwaysReformatBibProperty());
         autosaveLocalLibraries.selectedProperty().bindBidirectional(viewModel.autosaveLocalLibrariesProperty());
+
+        gitHubUsernameField.textProperty().bindBidirectional(viewModel.gitHubUsernameProperty());
+        gitHubPasskeyField.textProperty().bindBidirectional(viewModel.gitHubPasskeyProperty());
+
+        autoPushCheckbox.selectedProperty().bindBidirectional(viewModel.autoPushEnabledProperty());
+        autoPushModeComboBox.setItems(viewModel.autoPushModeListProperty());
+        autoPushModeComboBox.valueProperty().bindBidirectional(viewModel.autoPushModeProperty());
+
         ActionFactory actionFactory = new ActionFactory();
         actionFactory.configureIconButton(StandardActions.HELP, new HelpAction(HelpFile.AUTOSAVE, dialogService, preferences.getExternalApplicationsPreferences()), autosaveLocalLibrariesHelp);
         actionFactory.configureIconButton(StandardActions.HELP, new HelpAction(HelpFile.REMOTE, dialogService, preferences.getExternalApplicationsPreferences()), remoteHelp);
diff --git a/src/main/java/org/jabref/gui/preferences/general/GeneralTabViewModel.java b/src/main/java/org/jabref/gui/preferences/general/GeneralTabViewModel.java
index 70589770a79..368e798be55 100644
--- a/src/main/java/org/jabref/gui/preferences/general/GeneralTabViewModel.java
+++ b/src/main/java/org/jabref/gui/preferences/general/GeneralTabViewModel.java
@@ -32,9 +32,11 @@
 import org.jabref.gui.util.FileDialogConfiguration;
 import org.jabref.logic.FilePreferences;
 import org.jabref.logic.LibraryPreferences;
+import org.jabref.logic.git.GitPreferences;
 import org.jabref.logic.l10n.Language;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.logic.net.ssl.TrustStoreManager;
+import org.jabref.logic.preferences.AutoPushMode;
 import org.jabref.logic.remote.RemotePreferences;
 import org.jabref.logic.remote.RemoteUtil;
 import org.jabref.logic.remote.server.RemoteListenerServerManager;
@@ -64,6 +66,10 @@ public class GeneralTabViewModel implements PreferenceTabViewModel {
             new ReadOnlyListWrapper<>(FXCollections.observableArrayList(ThemeTypes.values()));
     private final ObjectProperty<ThemeTypes> selectedThemeProperty = new SimpleObjectProperty<>();
 
+    private final ReadOnlyListProperty<AutoPushMode> autoPushModeListProperty =
+            new ReadOnlyListWrapper<>(FXCollections.observableArrayList(AutoPushMode.values()));
+    private final ObjectProperty<AutoPushMode> autoPushModeProperty = new SimpleObjectProperty<>();
+
     private final BooleanProperty themeSyncOsProperty = new SimpleBooleanProperty();
 
     // init with empty string to avoid npe in accessing
@@ -94,6 +100,7 @@ public class GeneralTabViewModel implements PreferenceTabViewModel {
     private final LibraryPreferences libraryPreferences;
     private final FilePreferences filePreferences;
     private final RemotePreferences remotePreferences;
+    private final GitPreferences gitPreferences;
 
     private final Validator fontSizeValidator;
     private final Validator customPathToThemeValidator;
@@ -112,6 +119,7 @@ public GeneralTabViewModel(DialogService dialogService, GuiPreferences preferenc
         this.workspacePreferences = preferences.getWorkspacePreferences();
         this.libraryPreferences = preferences.getLibraryPreferences();
         this.filePreferences = preferences.getFilePreferences();
+        this.gitPreferences = preferences.getGitPreferences();
         this.remotePreferences = preferences.getRemotePreferences();
         this.fileUpdateMonitor = fileUpdateMonitor;
         this.entryTypesManager = entryTypesManager;
@@ -195,6 +203,11 @@ public void setValues() {
         alwaysReformatBibProperty.setValue(libraryPreferences.shouldAlwaysReformatOnSave());
         autosaveLocalLibraries.setValue(libraryPreferences.shouldAutoSave());
 
+        autoPushEnabledProperty().setValue(gitPreferences.getAutoPushEnabled());
+        autoPushModeProperty().setValue(gitPreferences.getAutoPushMode());
+        gitHubUsernameProperty().setValue(gitPreferences.getGitHubUsername());
+        gitHubPasskeyProperty().setValue(gitPreferences.getGitHubPasskey());
+
         createBackupProperty.setValue(filePreferences.shouldCreateBackup());
         backupDirectoryProperty.setValue(filePreferences.getBackupDirectory().toString());
 
@@ -237,6 +250,11 @@ public void storeSettings() {
         libraryPreferences.setAlwaysReformatOnSave(alwaysReformatBibProperty.getValue());
         libraryPreferences.setAutoSave(autosaveLocalLibraries.getValue());
 
+        gitPreferences.setAutoPushEnabled(autoPushEnabledProperty().get());
+        gitPreferences.setAutoPushMode(autoPushModeProperty().get());
+        gitPreferences.setGitHubUsername(gitHubUsernameProperty().get());
+        gitPreferences.setGitHubPasskey(gitHubPasskeyProperty().get());
+
         filePreferences.createBackupProperty().setValue(createBackupProperty.getValue());
         filePreferences.backupDirectoryProperty().setValue(Path.of(backupDirectoryProperty.getValue()));
 
@@ -440,4 +458,24 @@ private Optional<Integer> getPortAsInt(String value) {
             return Optional.empty();
         }
     }
+
+    public BooleanProperty autoPushEnabledProperty() {
+        return gitPreferences.getAutoPushEnabledProperty();
+    }
+
+    public ReadOnlyListProperty<AutoPushMode> autoPushModeListProperty() {
+        return this.autoPushModeListProperty;
+    }
+
+    public ObjectProperty<AutoPushMode> autoPushModeProperty() {
+        return this.autoPushModeProperty;
+    }
+
+    public StringProperty gitHubUsernameProperty() {
+        return gitPreferences.gitHubUsernameProperty();
+    }
+
+    public StringProperty gitHubPasskeyProperty() {
+        return gitPreferences.gitHubPasskeyProperty();
+    }
 }
diff --git a/src/main/java/org/jabref/gui/shared/GitPullAction.java b/src/main/java/org/jabref/gui/shared/GitPullAction.java
new file mode 100644
index 00000000000..83236770e13
--- /dev/null
+++ b/src/main/java/org/jabref/gui/shared/GitPullAction.java
@@ -0,0 +1,65 @@
+package org.jabref.gui.shared;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Optional;
+
+import org.jabref.gui.DialogService;
+import org.jabref.gui.StateManager;
+import org.jabref.gui.actions.SimpleCommand;
+import org.jabref.gui.preferences.GuiPreferences;
+import org.jabref.logic.git.GitClientHandler;
+import org.jabref.model.database.BibDatabaseContext;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class GitPullAction extends SimpleCommand {
+    private static final Logger LOGGER = LoggerFactory.getLogger(GitPullAction.class);
+
+    private final GuiPreferences preferences;
+    private final DialogService dialogService;
+    private final StateManager stateManager;
+
+    public GitPullAction(
+            GuiPreferences preferences,
+            DialogService dialogService,
+            StateManager stateManager) {
+        this.preferences = preferences;
+        this.dialogService = dialogService;
+        this.stateManager = stateManager;
+    }
+    /**
+     * Contains logic for performing Git operations on the active database repository.
+     * The method verifies that an active database exists and is not empty
+     * then creates a GitClientHandler with the parent directory of the database path.
+     * If the directory is a Git repository, performs a pull operation on the current branch.
+     * Will log any errors that occur during the pull operation.
+     */
+
+    @Override
+    public void execute() {
+        if (stateManager.getActiveDatabase().isEmpty()) {
+            return;
+        }
+        BibDatabaseContext databaseContext = stateManager.getActiveDatabase().get();
+
+        Optional<Path> path = databaseContext.getDatabasePath();
+        if (path.isEmpty()) {
+            return;
+        }
+
+        GitClientHandler gitClientHandler = new GitClientHandler(path.get().getParent(),
+                dialogService,
+                preferences.getGitPreferences());
+        if (gitClientHandler.isGitRepository()) {
+            try {
+                gitClientHandler.pullOnCurrentBranch();
+            } catch (IOException e) {
+                LOGGER.error("Failed to Pull", e);
+            }
+        } else {
+            LOGGER.info("Not a git repository at path: {}", path.get());
+        }
+    }
+}
diff --git a/src/main/java/org/jabref/gui/shared/GitPushAction.java b/src/main/java/org/jabref/gui/shared/GitPushAction.java
new file mode 100644
index 00000000000..7bbeebe3399
--- /dev/null
+++ b/src/main/java/org/jabref/gui/shared/GitPushAction.java
@@ -0,0 +1,60 @@
+package org.jabref.gui.shared;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Optional;
+
+import org.jabref.gui.DialogService;
+import org.jabref.gui.StateManager;
+import org.jabref.gui.actions.SimpleCommand;
+import org.jabref.gui.preferences.GuiPreferences;
+import org.jabref.logic.git.GitClientHandler;
+import org.jabref.model.database.BibDatabaseContext;
+
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class GitPushAction extends SimpleCommand {
+    private static final Logger LOGGER = LoggerFactory.getLogger(GitPushAction.class);
+
+    private final GuiPreferences preferences;
+    private final DialogService dialogService;
+    private final StateManager stateManager;
+
+    public GitPushAction(
+            GuiPreferences preferences,
+            DialogService dialogService,
+            StateManager stateManager) {
+        this.preferences = preferences;
+        this.dialogService = dialogService;
+        this.stateManager = stateManager;
+    }
+
+    @Override
+    public void execute() {
+        if (stateManager.getActiveDatabase().isEmpty()) {
+            return;
+        }
+        BibDatabaseContext databaseContext = stateManager.getActiveDatabase().get();
+
+        Optional<Path> path = databaseContext.getDatabasePath();
+        if (path.isEmpty()) {
+            return;
+        }
+
+        GitClientHandler gitClientHandler = new GitClientHandler(path.get().getParent(),
+                dialogService,
+                preferences.getGitPreferences());
+        if (gitClientHandler.isGitRepository()) {
+            try {
+                gitClientHandler.createCommitOnCurrentBranch("Automatic update via JabRef", false);
+                gitClientHandler.pushCommitsToRemoteRepository();
+            } catch (IOException | GitAPIException e) {
+                dialogService.showErrorDialogAndWait(e);
+            }
+        } else {
+            LOGGER.info("Not a git repository at path: {}", path);
+        }
+    }
+}
diff --git a/src/main/java/org/jabref/logic/git/GitClientHandler.java b/src/main/java/org/jabref/logic/git/GitClientHandler.java
new file mode 100644
index 00000000000..55a4c67c58c
--- /dev/null
+++ b/src/main/java/org/jabref/logic/git/GitClientHandler.java
@@ -0,0 +1,139 @@
+package org.jabref.logic.git;
+
+import java.io.IOException;
+import java.nio.file.Path;
+import java.util.Optional;
+
+import org.jabref.gui.DialogService;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.preferences.AutoPushMode;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.ResetCommand;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.eclipse.jgit.lib.Ref;
+import org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider;
+
+public class GitClientHandler extends GitHandler {
+    private final DialogService dialogService;
+    private final GitPreferences gitPreferences;
+
+    public GitClientHandler(Path repositoryPath,
+                            DialogService dialogService,
+                            GitPreferences gitPreferences) {
+        super(repositoryPath, false);
+        this.dialogService = dialogService;
+        this.gitPreferences = gitPreferences;
+
+        this.credentialsProvider = new UsernamePasswordCredentialsProvider(
+                gitPreferences.getGitHubUsername(),
+                gitPreferences.getGitHubPasskey()
+        );
+    }
+
+    /**
+     * Contains logic for commiting and pushing after a database is saved locally,
+     * if the relevant preferences are present.<p>
+     * A git commit is created and a 'git pull --rebase' is executed. In the case of
+     * an error, the repository is reverted to the commit and a regular pull is executed.
+     */
+    public void postSaveDatabaseAction() {
+        if (this.isGitRepository() &&
+                gitPreferences.getAutoPushMode() == AutoPushMode.ON_SAVE &&
+                gitPreferences.getAutoPushEnabled()) {
+            try {
+                this.createCommitOnCurrentBranch("Automatic update via JabRef", false);
+            } catch (GitAPIException | IOException e) {
+                return;
+            }
+
+            try {
+                this.pullAndRebaseOnCurrentBranch();
+            } catch (IOException | GitAPIException e) {
+                // In the case that rebase fails, try revert to previous commit
+                // and execute regular pull
+                Optional<Ref> headRef = Optional.empty();
+                try {
+                    headRef = this.getHeadRef();
+                } catch (IOException | GitAPIException ex) {
+                    LOGGER.error("Cannot find HEAD on current branch");
+                }
+                if (headRef.isEmpty()) {
+                    return;
+                }
+
+                try {
+                    this.revertToCommit(headRef.get());
+                } catch (IOException | GitAPIException ex) {
+                    LOGGER.error("Failed to revert to commit");
+                }
+
+                try {
+                    this.pullOnCurrentBranch();
+                } catch (IOException ex) {
+                    LOGGER.error("Failed to pull");
+                    dialogService.notify(Localization.lang("Failed to update repository"));
+                    // TODO: Detect if a merge conflict occurs at this point and resolve
+                    return;
+                }
+            }
+            dialogService.notify(Localization.lang("Successfully pulled"));
+
+            try {
+                this.pushCommitsToRemoteRepository();
+                dialogService.notify(Localization.lang("Succesfully pushed"));
+            } catch (IOException e) {
+                dialogService.notify(Localization.lang("Failed to push"));
+            }
+        }
+    }
+
+    @Override
+    public void pullOnCurrentBranch() throws IOException {
+        try (Git git = Git.open(this.repositoryPathAsFile)) {
+            try {
+                git.pull()
+                   .setCredentialsProvider(credentialsProvider)
+                   .call();
+                dialogService.notify(Localization.lang("Successfully updated local repository"));
+            } catch (GitAPIException e) {
+                dialogService.notify(Localization.lang("Failed to pull from remote repository"));
+                LOGGER.error("Git pull failed");
+            }
+        }
+    }
+
+    public void pushCommitsToRemoteRepository() throws IOException {
+        try (Git git = Git.open(this.repositoryPathAsFile)) {
+            try {
+                git.push()
+                   .setCredentialsProvider(credentialsProvider)
+                   .call();
+                dialogService.notify(Localization.lang("Successfully updated remote repository"));
+            } catch (GitAPIException e) {
+                dialogService.notify(Localization.lang("Failed to push to remote repository"));
+                LOGGER.error("Git push failed", e);
+            }
+        }
+    }
+
+    private Optional<Ref> getHeadRef() throws IOException, GitAPIException {
+        return this.getRefForBranch(this.getCurrentlyCheckedOutBranch());
+    }
+
+    private void revertToCommit(Ref commit) throws IOException, GitAPIException {
+        Git git = Git.open(this.repositoryPathAsFile);
+        git.reset()
+           .setMode(ResetCommand.ResetType.SOFT)
+           .setRef(commit.toString())
+           .call();
+    }
+
+    private void pullAndRebaseOnCurrentBranch() throws IOException, GitAPIException {
+        Git git = Git.open(this.repositoryPathAsFile);
+        git.pull()
+           .setCredentialsProvider(credentialsProvider)
+           .setRebase(true)
+           .call();
+    }
+}
diff --git a/src/main/java/org/jabref/logic/git/GitHandler.java b/src/main/java/org/jabref/logic/git/GitHandler.java
index 77a78681428..4ea36205fad 100644
--- a/src/main/java/org/jabref/logic/git/GitHandler.java
+++ b/src/main/java/org/jabref/logic/git/GitHandler.java
@@ -28,7 +28,7 @@ public class GitHandler {
     final File repositoryPathAsFile;
     String gitUsername = Optional.ofNullable(System.getenv("GIT_EMAIL")).orElse("");
     String gitPassword = Optional.ofNullable(System.getenv("GIT_PW")).orElse("");
-    final CredentialsProvider credentialsProvider = new UsernamePasswordCredentialsProvider(gitUsername, gitPassword);
+    CredentialsProvider credentialsProvider = new UsernamePasswordCredentialsProvider(gitUsername, gitPassword);
 
     /**
      * Initialize the handler for the given repository
@@ -36,28 +36,40 @@ public class GitHandler {
      * @param repositoryPath The root of the initialized git repository
      */
     public GitHandler(Path repositoryPath) {
+        this(repositoryPath, true);
+    }
+
+    /**
+     * Initialize the handler for the given repository
+     *
+     * @param repositoryPath The root of the initialized git repository
+     * @param createRepo If true, initializes a repository if the file path does not contain a repository
+     */
+    public GitHandler(Path repositoryPath, boolean createRepo) {
         this.repositoryPath = repositoryPath;
         this.repositoryPathAsFile = this.repositoryPath.toFile();
         if (!isGitRepository()) {
-            try {
-                Git.init()
-                   .setDirectory(repositoryPathAsFile)
-                   .setInitialBranch("main")
-                   .call();
-                setupGitIgnore();
-                String initialCommit = "Initial commit";
-                if (!createCommitOnCurrentBranch(initialCommit, false)) {
-                    // Maybe, setupGitIgnore failed and did not add something
-                    // Then, we create an empty commit
-                    try (Git git = Git.open(repositoryPathAsFile)) {
-                        git.commit()
-                           .setAllowEmpty(true)
-                           .setMessage(initialCommit)
-                           .call();
+            if (createRepo) {
+                try {
+                    Git.init()
+                       .setDirectory(repositoryPathAsFile)
+                       .setInitialBranch("main")
+                       .call();
+                    setupGitIgnore();
+                    String initialCommit = "Initial commit";
+                    if (!createCommitOnCurrentBranch(initialCommit, false)) {
+                        // Maybe, setupGitIgnore failed and did not add something
+                        // Then, we create an empty commit
+                        try (Git git = Git.open(repositoryPathAsFile)) {
+                            git.commit()
+                               .setAllowEmpty(true)
+                               .setMessage(initialCommit)
+                               .call();
+                        }
                     }
+                } catch (GitAPIException | IOException e) {
+                    LOGGER.error("Initialization failed.", e);
                 }
-            } catch (GitAPIException | IOException e) {
-                LOGGER.error("Initialization failed");
             }
         }
     }
@@ -76,7 +88,7 @@ void setupGitIgnore() {
     /**
      * Returns true if the given path points to a directory that is a git repository (contains a .git folder)
      */
-    boolean isGitRepository() {
+    public boolean isGitRepository() {
         // For some reason the solution from https://www.eclipse.org/lists/jgit-dev/msg01892.html does not work
         // This solution is quite simple but might not work in special cases, for us it should suffice.
         return Files.exists(Path.of(repositoryPath.toString(), ".git"));
@@ -180,7 +192,7 @@ public void pushCommitsToRemoteRepository() throws IOException {
                    .setCredentialsProvider(credentialsProvider)
                    .call();
             } catch (GitAPIException e) {
-                LOGGER.info("Failed to push");
+                LOGGER.error("Git push failed", e);
             }
         }
     }
@@ -192,7 +204,7 @@ public void pullOnCurrentBranch() throws IOException {
                    .setCredentialsProvider(credentialsProvider)
                    .call();
             } catch (GitAPIException e) {
-                LOGGER.info("Failed to push");
+                LOGGER.error("Git pull failed", e);
             }
         }
     }
diff --git a/src/main/java/org/jabref/logic/git/GitPreferences.java b/src/main/java/org/jabref/logic/git/GitPreferences.java
new file mode 100644
index 00000000000..5ec95289cd6
--- /dev/null
+++ b/src/main/java/org/jabref/logic/git/GitPreferences.java
@@ -0,0 +1,72 @@
+package org.jabref.logic.git;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+
+import org.jabref.logic.preferences.AutoPushMode;
+
+public class GitPreferences {
+    private final BooleanProperty autoPushEnabled;
+    private final ObjectProperty<AutoPushMode> autoPushMode;
+    private final StringProperty gitHubUsername;
+    private final StringProperty gitHubPasskey;
+
+    public GitPreferences(boolean autoPushEnabled, AutoPushMode autoPushMode, String gitHubUsername, String gitHubPasskey) {
+        this.autoPushEnabled = new SimpleBooleanProperty(autoPushEnabled);
+        this.autoPushMode = new SimpleObjectProperty<>(autoPushMode);
+        this.gitHubUsername = new SimpleStringProperty(gitHubUsername);
+        this.gitHubPasskey = new SimpleStringProperty(gitHubPasskey);
+    }
+
+    public boolean getAutoPushEnabled() {
+        return autoPushEnabled.get();
+    }
+
+    public BooleanProperty getAutoPushEnabledProperty() {
+        return autoPushEnabled;
+    }
+
+    public void setAutoPushEnabled(boolean enabled) {
+        autoPushEnabled.set(enabled);
+    }
+
+    public AutoPushMode getAutoPushMode() {
+        return autoPushMode.get();
+    }
+
+    public ObjectProperty<AutoPushMode> getAutoPushModeProperty() {
+        return autoPushMode;
+    }
+
+    public void setAutoPushMode(AutoPushMode mode) {
+        autoPushMode.set(mode);
+    }
+
+    public String getGitHubUsername() {
+        return gitHubUsername.get();
+    }
+
+    public void setGitHubUsername(String username) {
+        gitHubUsername.set(username);
+    }
+
+    public StringProperty gitHubUsernameProperty() {
+        return gitHubUsername;
+    }
+
+    public String getGitHubPasskey() {
+        return gitHubPasskey.get();
+    }
+
+    public void setGitHubPasskey(String passkey) {
+        gitHubPasskey.set(passkey);
+    }
+
+    public StringProperty gitHubPasskeyProperty() {
+        return gitHubPasskey;
+    }
+}
diff --git a/src/main/java/org/jabref/logic/preferences/AutoPushMode.java b/src/main/java/org/jabref/logic/preferences/AutoPushMode.java
new file mode 100644
index 00000000000..c236af2fc25
--- /dev/null
+++ b/src/main/java/org/jabref/logic/preferences/AutoPushMode.java
@@ -0,0 +1,31 @@
+package org.jabref.logic.preferences;
+
+import org.jabref.logic.l10n.Localization;
+
+public enum AutoPushMode {
+    ON_SAVE(Localization.lang("On save"));
+
+    private final String displayName;
+
+    AutoPushMode(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public String getDisplayName() {
+        return displayName;
+    }
+
+    @Override
+    public String toString() {
+        return displayName;
+    }
+
+    public static AutoPushMode fromString(String text) {
+        for (AutoPushMode mode : AutoPushMode.values()) {
+            if (mode.displayName.equalsIgnoreCase(text)) {
+                return mode;
+            }
+        }
+        return ON_SAVE;
+    }
+}
diff --git a/src/main/java/org/jabref/logic/preferences/CliPreferences.java b/src/main/java/org/jabref/logic/preferences/CliPreferences.java
index 0d39cdf55a1..73eb2efb993 100644
--- a/src/main/java/org/jabref/logic/preferences/CliPreferences.java
+++ b/src/main/java/org/jabref/logic/preferences/CliPreferences.java
@@ -14,6 +14,7 @@
 import org.jabref.logic.cleanup.CleanupPreferences;
 import org.jabref.logic.exporter.ExportPreferences;
 import org.jabref.logic.exporter.SelfContainedSaveConfiguration;
+import org.jabref.logic.git.GitPreferences;
 import org.jabref.logic.importer.ImportFormatPreferences;
 import org.jabref.logic.importer.ImporterPreferences;
 import org.jabref.logic.importer.fetcher.MrDlibPreferences;
@@ -67,7 +68,8 @@ public interface CliPreferences {
     ImportFormatPreferences getImportFormatPreferences();
 
     /**
-     * Returns the export configuration. The contained SaveConfiguration is a {@link org.jabref.model.metadata.SelfContainedSaveOrder}
+     * Returns the export configuration. The contained SaveConfiguration is a
+     * {@link org.jabref.model.metadata.SelfContainedSaveOrder}
      */
     SelfContainedSaveConfiguration getSelfContainedExportConfiguration();
 
@@ -116,4 +118,6 @@ public interface CliPreferences {
     AiPreferences getAiPreferences();
 
     LastFilesOpenedPreferences getLastFilesOpenedPreferences();
+  
+    GitPreferences getGitPreferences();
 }
diff --git a/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java b/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
index b350ebebb24..0e32503eb1c 100644
--- a/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
+++ b/src/main/java/org/jabref/logic/preferences/JabRefCliPreferences.java
@@ -51,6 +51,7 @@
 import org.jabref.logic.exporter.MetaDataSerializer;
 import org.jabref.logic.exporter.SelfContainedSaveConfiguration;
 import org.jabref.logic.exporter.TemplateExporter;
+import org.jabref.logic.git.GitPreferences;
 import org.jabref.logic.importer.ImportFormatPreferences;
 import org.jabref.logic.importer.ImporterPreferences;
 import org.jabref.logic.importer.fetcher.ACMPortalFetcher;
@@ -120,6 +121,8 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import static org.apache.commons.compress.harmony.archive.internal.nls.Messages.getString;
+
 /**
  * The {@code JabRefPreferences} class provides the preferences and their defaults using the JDK {@code java.util.prefs}
  * class.
@@ -421,6 +424,9 @@ public class JabRefCliPreferences implements CliPreferences {
     private FieldPreferences fieldPreferences;
     private AiPreferences aiPreferences;
     private LastFilesOpenedPreferences lastFilesOpenedPreferences;
+    private GitPreferences gitPreferences;
+
+    private boolean autoPullEnabled;
 
     /**
      * @implNote The constructor is made protected to enforce this as a singleton class:
@@ -1819,6 +1825,44 @@ public LastFilesOpenedPreferences getLastFilesOpenedPreferences() {
         return lastFilesOpenedPreferences;
     }
 
+    @Override
+    public GitPreferences getGitPreferences() {
+        if (gitPreferences != null) {
+            return gitPreferences;
+        }
+
+        boolean autoPushEnabled = getBoolean("gitAutoPushEnabled", false);
+        String storedMode = getString("gitAutoPushMode", AutoPushMode.ON_SAVE.name());
+        AutoPushMode autoPushMode = AutoPushMode.fromString(storedMode);
+
+        String gitHubUsername = getString("gitHubUsername", "");
+        String gitHubPasskey = getString("gitHubPasskey", "");
+
+        gitPreferences = new GitPreferences(autoPushEnabled, autoPushMode, gitHubUsername, gitHubPasskey);
+
+        EasyBind.listen(gitPreferences.getAutoPushEnabledProperty(), (obs, oldValue, newValue) ->
+                putBoolean("gitAutoPushEnabled", newValue)
+        );
+
+        EasyBind.listen(gitPreferences.getAutoPushModeProperty(), (obs, oldValue, newValue) ->
+                putString("gitAutoPushMode", newValue.name())
+        );
+
+        EasyBind.listen(gitPreferences.gitHubUsernameProperty(), (obs, oldValue, newValue) ->
+                putString("gitHubUsername", newValue)
+        );
+
+        EasyBind.listen(gitPreferences.gitHubPasskeyProperty(), (obs, oldValue, newValue) ->
+                putString("gitHubPasskey", newValue)
+        );
+
+        return gitPreferences;
+    }
+
+    private void putString(String key, String value) {
+        prefs.put(key, value);
+    }
+
     private FileHistory getFileHistory() {
         return FileHistory.of(getStringList(RECENT_DATABASES).stream()
                                                              .map(Path::of)
@@ -2234,5 +2278,9 @@ public ImportFormatPreferences getImportFormatPreferences() {
                 getGrobidPreferences());
     }
 
+    public boolean shouldAutoPull() {
+        return autoPullEnabled;
+    }
+
     // endregion
 }
diff --git a/src/main/java/org/jabref/model/database/BibDatabaseContext.java b/src/main/java/org/jabref/model/database/BibDatabaseContext.java
index 2efba5d6c65..cc23c2d144d 100644
--- a/src/main/java/org/jabref/model/database/BibDatabaseContext.java
+++ b/src/main/java/org/jabref/model/database/BibDatabaseContext.java
@@ -43,6 +43,7 @@ public class BibDatabaseContext {
 
     private final BibDatabase database;
     private MetaData metaData;
+    private Boolean underVersionControl;
 
     /**
      * Generate a random UID for unique of the concrete context
@@ -315,4 +316,12 @@ public int hashCode() {
     public String getUid() {
         return uid;
     }
+
+    public boolean isVersioned() {
+        return Boolean.TRUE.equals(underVersionControl);
+    }
+
+    public void setVersioned(boolean versioned) {
+        this.underVersionControl = versioned;
+    }
 }
diff --git a/src/main/resources/l10n/JabRef_en.properties b/src/main/resources/l10n/JabRef_en.properties
index e7496463445..d8221ded2e3 100644
--- a/src/main/resources/l10n/JabRef_en.properties
+++ b/src/main/resources/l10n/JabRef_en.properties
@@ -798,6 +798,7 @@ Could\ not\ save,\ file\ locked\ by\ another\ JabRef\ instance.=Could not save,
 Saved\ selected\ to\ '%0'.=Saved selected to '%0'.
 Autosave\ local\ libraries=Autosave local libraries
 Automatically\ save\ the\ library\ to=Automatically save the library to
+On\ save=On save
 Please\ enter\ a\ valid\ file\ path.=Please enter a valid file path.
 Overwrite\ file=Overwrite file
 Unable\ to\ write\ to\ %0.=Unable to write to %0.
@@ -1433,6 +1434,9 @@ Focus\ entry\ table=Focus entry table
 Focus\ group\ list=Focus group list
 Import\ into\ current\ library=Import into current library
 Import\ into\ new\ library=Import into new library
+Git=Git
+Git\ Pull=Git Pull
+Git\ Push=Git Push
 New\ article=New article
 New\ book=New book
 New\ entry=New entry
diff --git a/src/test/java/org/jabref/gui/importer/actions/CheckForVersionControlActionEndToEndTest.java b/src/test/java/org/jabref/gui/importer/actions/CheckForVersionControlActionEndToEndTest.java
new file mode 100644
index 00000000000..f3d42b2819e
--- /dev/null
+++ b/src/test/java/org/jabref/gui/importer/actions/CheckForVersionControlActionEndToEndTest.java
@@ -0,0 +1,93 @@
+package org.jabref.gui.importer.actions;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Optional;
+
+import org.jabref.gui.DialogService;
+import org.jabref.logic.importer.ParserResult;
+import org.jabref.logic.preferences.CliPreferences;
+import org.jabref.model.database.BibDatabaseContext;
+
+import org.eclipse.jgit.api.Git;
+import org.eclipse.jgit.api.errors.GitAPIException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class CheckForVersionControlActionEndToEndTest {
+    @TempDir
+    Path tempDir;
+
+    private CheckForVersionControlAction action;
+    private ParserResult parserResult;
+    private DialogService dialogService;
+    private CliPreferences cliPreferences;
+    private BibDatabaseContext databaseContext;
+    private Path gitRepo;
+
+    @BeforeEach
+    void setUp() throws IOException, GitAPIException {
+        gitRepo = tempDir.resolve("git-test-repo");
+        Files.createDirectories(gitRepo);
+
+        Git.init()
+           .setDirectory(gitRepo.toFile())
+           .call()
+           .close();
+
+        Path testFile = gitRepo.resolve("test.bib");
+        Files.writeString(testFile, "@article{test, author={Test Author}, title={Test Title}}");
+
+        action = new CheckForVersionControlAction();
+        parserResult = mock(ParserResult.class);
+        dialogService = mock(DialogService.class);
+        cliPreferences = mock(CliPreferences.class);
+        databaseContext = mock(BibDatabaseContext.class);
+
+        when(parserResult.getDatabaseContext()).thenReturn(databaseContext);
+    }
+
+    @Test
+    void isActionNecessary_WhenDatabasePathExistsAndIsAGitRepo_ShouldReturnTrue() {
+        when(databaseContext.getDatabasePath()).thenReturn(Optional.of(gitRepo.resolve("test.bib")));
+
+        boolean result = action.isActionNecessary(parserResult, dialogService, cliPreferences);
+
+        assertTrue(result);
+    }
+
+    @Test
+    void isActionNecessary_WhenDatabasePathExistsButNotAGitRepo_ShouldReturnFalse() {
+        Path nonGitDir = tempDir.resolve("non-git-dir");
+        try {
+            Files.createDirectories(nonGitDir);
+            Path nonGitFile = nonGitDir.resolve("test.bib");
+            Files.writeString(nonGitFile, "@article{test, author={Test Author}, title={Test Title}}");
+
+            when(databaseContext.getDatabasePath()).thenReturn(Optional.of(nonGitFile));
+
+            boolean result = action.isActionNecessary(parserResult, dialogService, cliPreferences);
+
+            assertFalse(result);
+        } catch (IOException e) {
+            throw new AssertionError("Failed to set up test directory", e);
+        }
+    }
+
+    @Test
+    void performAction_WhenGitPullSucceeds_ShouldNotThrowException() {
+        when(databaseContext.getDatabasePath()).thenReturn(Optional.of(gitRepo.resolve("test.bib")));
+
+        action.isActionNecessary(parserResult, dialogService, cliPreferences);
+
+        assertDoesNotThrow(() -> action.performAction(parserResult, dialogService, cliPreferences));
+    }
+}
diff --git a/src/test/java/org/jabref/logic/git/GitPreferencesTest.java b/src/test/java/org/jabref/logic/git/GitPreferencesTest.java
new file mode 100644
index 00000000000..0b9c9d41768
--- /dev/null
+++ b/src/test/java/org/jabref/logic/git/GitPreferencesTest.java
@@ -0,0 +1,50 @@
+package org.jabref.logic.git;
+
+import javafx.beans.property.BooleanProperty;
+
+import org.jabref.logic.preferences.AutoPushMode;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
+
+class GitPreferencesTest {
+
+    private GitPreferences gitPreferences;
+
+    @BeforeEach
+    void setUp() {
+        gitPreferences = new GitPreferences(true, AutoPushMode.ON_SAVE, "", "");
+    }
+
+    @Test
+    void constructorInitialisesValues() {
+        assertThat(gitPreferences.getAutoPushEnabled()).isTrue();
+        assertThat(gitPreferences.getAutoPushMode()).isEqualTo(AutoPushMode.ON_SAVE);
+    }
+
+    @Test
+    void gettersReturnCorrectValues() {
+        assertThat(gitPreferences.getAutoPushEnabled()).isTrue();
+        assertThat(gitPreferences.getAutoPushMode()).isEqualTo(AutoPushMode.ON_SAVE);
+    }
+
+    @Test
+    void setAutoPushEnabledUpdatesValue() {
+        gitPreferences.setAutoPushEnabled(false);
+        assertThat(gitPreferences.getAutoPushEnabled()).isFalse();
+    }
+
+    @Test
+    void javaFXBooleanPropertyUpdates() {
+        BooleanProperty autoPushProperty = gitPreferences.getAutoPushEnabledProperty();
+        autoPushProperty.set(false);
+        assertThat(gitPreferences.getAutoPushEnabled()).isFalse();
+    }
+
+    @Test
+    void autoPushModeFromString() {
+        assertThat(AutoPushMode.fromString("On Save")).isEqualTo(AutoPushMode.ON_SAVE);
+    }
+}