diff --git a/CHANGELOG.md b/CHANGELOG.md
index bca01e2d50f..ce6a2adcd32 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -69,6 +69,7 @@ We refer to [GitHub issues](https://github.com/JabRef/jabref/issues) by using `#
 - We moved the dropdown menu for selecting the push-application from the toolbar into the external application preferences. [#674](https://github.com/JabRef/jabref/issues/674)
 - We removed the alphabetical ordering of the custom tabs and updated the error message when trying to create a general field with a name containing an illegal character. [#5019](https://github.com/JabRef/jabref/issues/5019)
 - We added a context menu to the bib(la)tex-source-editor to copy'n'paste. [#5007](https://github.com/JabRef/jabref/pull/5007)
+- We added a bibliographic references search, for finding references in several LaTeX files. This tool scans directories and shows which entries are used, how many times and where.
 
 
 ### Fixed
diff --git a/src/main/java/org/jabref/gui/JabRefFrame.java b/src/main/java/org/jabref/gui/JabRefFrame.java
index 73f838d6315..9922adca817 100644
--- a/src/main/java/org/jabref/gui/JabRefFrame.java
+++ b/src/main/java/org/jabref/gui/JabRefFrame.java
@@ -101,6 +101,7 @@
 import org.jabref.gui.search.GlobalSearchBar;
 import org.jabref.gui.shared.ConnectToSharedDatabaseCommand;
 import org.jabref.gui.specialfields.SpecialFieldMenuItemFactory;
+import org.jabref.gui.texparser.ParseTexAction;
 import org.jabref.gui.undo.CountingUndoManager;
 import org.jabref.gui.util.BackgroundTask;
 import org.jabref.gui.util.DefaultTaskExecutor;
@@ -768,6 +769,7 @@ private MenuBar createMenu() {
         pushToApplicationsManager.setMenuItem(pushToApplicationMenuItem);
 
         tools.getItems().addAll(
+                factory.createMenuItem(StandardActions.PARSE_TEX, new ParseTexAction(stateManager)),
                 factory.createMenuItem(StandardActions.NEW_SUB_LIBRARY_FROM_AUX, new NewSubLibraryAction(this, stateManager)),
                 factory.createMenuItem(StandardActions.FIND_UNLINKED_FILES, new FindUnlinkedFilesAction(this, stateManager)),
                 factory.createMenuItem(StandardActions.WRITE_XMP, new OldDatabaseCommandWrapper(Actions.WRITE_XMP, this, stateManager)),
diff --git a/src/main/java/org/jabref/gui/actions/StandardActions.java b/src/main/java/org/jabref/gui/actions/StandardActions.java
index eb4c6508955..feb1e072275 100644
--- a/src/main/java/org/jabref/gui/actions/StandardActions.java
+++ b/src/main/java/org/jabref/gui/actions/StandardActions.java
@@ -85,6 +85,7 @@ public enum StandardActions implements Action {
     TOOGLE_OO(Localization.lang("OpenOffice/LibreOffice"), IconTheme.JabRefIcons.FILE_OPENOFFICE, KeyBinding.OPEN_OPEN_OFFICE_LIBRE_OFFICE_CONNECTION),
     TOGGLE_WEB_SEARCH(Localization.lang("Web search"), Localization.lang("Toggle web search interface"), IconTheme.JabRefIcons.WWW, KeyBinding.WEB_SEARCH),
 
+    PARSE_TEX(Localization.lang("LaTeX references search"), IconTheme.JabRefIcons.APPLICATION_TEXSTUDIO),
     NEW_SUB_LIBRARY_FROM_AUX(Localization.lang("New sublibrary based on AUX file") + "...", Localization.lang("New BibTeX sublibrary") + Localization.lang("This feature generates a new library based on which entries are needed in an existing LaTeX document."), IconTheme.JabRefIcons.NEW),
     WRITE_XMP(Localization.lang("Write XMP-metadata to PDFs"), Localization.lang("Will write XMP-metadata to the PDFs linked from selected entries."), KeyBinding.WRITE_XMP),
     OPEN_FOLDER(Localization.lang("Open folder"), Localization.lang("Open folder"), KeyBinding.OPEN_FOLDER),
diff --git a/src/main/java/org/jabref/gui/texparser/FileNodeViewModel.java b/src/main/java/org/jabref/gui/texparser/FileNodeViewModel.java
new file mode 100644
index 00000000000..63c743df3fc
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/FileNodeViewModel.java
@@ -0,0 +1,58 @@
+package org.jabref.gui.texparser;
+
+import java.nio.file.Path;
+import java.util.StringJoiner;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+import org.jabref.logic.l10n.Localization;
+
+class FileNodeViewModel {
+
+    private final Path path;
+    private final ObservableList<FileNodeViewModel> children;
+    private int fileCount;
+
+    public FileNodeViewModel(Path path) {
+        this.path = path;
+        this.fileCount = 0;
+        this.children = FXCollections.observableArrayList();
+    }
+
+    public Path getPath() {
+        return path;
+    }
+
+    public int getFileCount() {
+        return fileCount;
+    }
+
+    public void setFileCount(int fileCount) {
+        this.fileCount = fileCount;
+    }
+
+    public ObservableList<FileNodeViewModel> getChildren() {
+        return children;
+    }
+
+    /**
+     * Return a string for displaying a node name (and its number of children if it is a directory).
+     */
+    public String getDisplayText() {
+        if (path.toFile().isDirectory()) {
+            return String.format("%s (%s %s)", path.getFileName(), fileCount,
+                    fileCount == 1 ? Localization.lang("file") : Localization.lang("files"));
+        }
+        return path.getFileName().toString();
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", FileNodeViewModel.class.getSimpleName() + "[", "]")
+                .add("path=" + path)
+                .add("fileCount=" + fileCount)
+                .add("children=" + children)
+                .toString();
+    }
+}
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexAction.java b/src/main/java/org/jabref/gui/texparser/ParseTexAction.java
new file mode 100644
index 00000000000..b057f040ab2
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexAction.java
@@ -0,0 +1,25 @@
+package org.jabref.gui.texparser;
+
+import org.jabref.gui.StateManager;
+import org.jabref.gui.actions.SimpleCommand;
+import org.jabref.model.database.BibDatabaseContext;
+
+import static org.jabref.gui.actions.ActionHelper.needsDatabase;
+
+public class ParseTexAction extends SimpleCommand {
+
+    private final StateManager stateManager;
+
+    public ParseTexAction(StateManager stateManager) {
+        this.stateManager = stateManager;
+        this.executable.bind(needsDatabase(stateManager));
+    }
+
+    @Override
+    public void execute() {
+        BibDatabaseContext database = stateManager.getActiveDatabase().orElseThrow(NullPointerException::new);
+        ParseTexDialogView dialog = new ParseTexDialogView(database);
+
+        dialog.showAndWait();
+    }
+}
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexDialog.fxml b/src/main/java/org/jabref/gui/texparser/ParseTexDialog.fxml
new file mode 100644
index 00000000000..ee6fa85c697
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexDialog.fxml
@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.Button?>
+<?import javafx.scene.control.ButtonType?>
+<?import javafx.scene.control.DialogPane?>
+<?import javafx.scene.control.Label?>
+<?import javafx.scene.control.ProgressIndicator?>
+<?import javafx.scene.control.TextField?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.VBox?>
+<?import org.controlsfx.control.CheckTreeView?>
+
+<DialogPane xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1"
+            fx:controller="org.jabref.gui.texparser.ParseTexDialogView"
+            prefWidth="500.0" prefHeight="650.0">
+    <content>
+        <VBox spacing="10.0">
+            <VBox spacing="5.0">
+                <Label text="%LaTeX files directory:"/>
+                <HBox spacing="10.0">
+                    <TextField fx:id="texDirectoryField" HBox.hgrow="ALWAYS"/>
+                    <Button fx:id="browseButton" onAction="#browseButtonClicked" text="%Browse"/>
+                    <Button fx:id="searchButton" defaultButton="true" onAction="#searchButtonClicked" text="%Search"/>
+                </HBox>
+            </VBox>
+            <VBox spacing="5.0">
+                <Label text="%LaTeX files found:"/>
+                <CheckTreeView fx:id="fileTreeView" prefHeight="500.0" VBox.vgrow="ALWAYS"/>
+            </VBox>
+            <VBox spacing="5.0">
+                <HBox spacing="10.0">
+                    <Button fx:id="selectAllButton" text="%Select all" styleClass="text-button" onAction="#selectAll"/>
+                    <Button fx:id="unselectAllButton" text="%Unselect all" styleClass="text-button"
+                            onAction="#unselectAll"/>
+                </HBox>
+            </VBox>
+            <ProgressIndicator fx:id="progressIndicator" prefHeight="200.0"/>
+        </VBox>
+    </content>
+    <ButtonType fx:constant="CLOSE"/>
+    <ButtonType fx:id="parseButtonType" text="%Parse"/>
+</DialogPane>
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexDialogView.java b/src/main/java/org/jabref/gui/texparser/ParseTexDialogView.java
new file mode 100644
index 00000000000..d5ffc866404
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexDialogView.java
@@ -0,0 +1,113 @@
+package org.jabref.gui.texparser;
+
+import javax.inject.Inject;
+
+import javafx.beans.binding.Bindings;
+import javafx.fxml.FXML;
+import javafx.scene.control.Button;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.CheckBoxTreeItem;
+import javafx.scene.control.ProgressIndicator;
+import javafx.scene.control.SelectionMode;
+import javafx.scene.control.TextField;
+
+import org.jabref.gui.DialogService;
+import org.jabref.gui.util.BaseDialog;
+import org.jabref.gui.util.ControlHelper;
+import org.jabref.gui.util.IconValidationDecorator;
+import org.jabref.gui.util.RecursiveTreeItem;
+import org.jabref.gui.util.TaskExecutor;
+import org.jabref.gui.util.ViewModelTreeCellFactory;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.preferences.PreferencesService;
+
+import com.airhacks.afterburner.views.ViewLoader;
+import de.saxsys.mvvmfx.utils.validation.visualization.ControlsFxVisualizer;
+import org.controlsfx.control.CheckTreeView;
+import org.fxmisc.easybind.EasyBind;
+
+public class ParseTexDialogView extends BaseDialog<Void> {
+
+    private final BibDatabaseContext databaseContext;
+    private final ControlsFxVisualizer validationVisualizer;
+    @FXML private TextField texDirectoryField;
+    @FXML private Button browseButton;
+    @FXML private Button searchButton;
+    @FXML private ProgressIndicator progressIndicator;
+    @FXML private CheckTreeView<FileNodeViewModel> fileTreeView;
+    @FXML private Button selectAllButton;
+    @FXML private Button unselectAllButton;
+    @FXML private ButtonType parseButtonType;
+    @Inject private DialogService dialogService;
+    @Inject private TaskExecutor taskExecutor;
+    @Inject private PreferencesService preferencesService;
+    private ParseTexDialogViewModel viewModel;
+
+    public ParseTexDialogView(BibDatabaseContext databaseContext) {
+        this.databaseContext = databaseContext;
+        this.validationVisualizer = new ControlsFxVisualizer();
+
+        this.setTitle(Localization.lang("LaTeX references search"));
+
+        ViewLoader.view(this)
+                  .load()
+                  .setAsDialogPane(this);
+
+        ControlHelper.setAction(parseButtonType, getDialogPane(), event -> viewModel.parseButtonClicked());
+        Button parseButton = (Button) getDialogPane().lookupButton(parseButtonType);
+        parseButton.disableProperty().bind(viewModel.noFilesFoundProperty().or(
+                Bindings.isEmpty(viewModel.getCheckedFileList())));
+    }
+
+    @FXML
+    private void initialize() {
+        viewModel = new ParseTexDialogViewModel(databaseContext, dialogService, taskExecutor, preferencesService);
+
+        fileTreeView.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
+        fileTreeView.showRootProperty().bindBidirectional(viewModel.successfulSearchProperty());
+        fileTreeView.rootProperty().bind(EasyBind.map(viewModel.rootProperty(), fileNode ->
+                new RecursiveTreeItem<>(fileNode, FileNodeViewModel::getChildren)));
+
+        EasyBind.subscribe(fileTreeView.rootProperty(), root -> {
+            ((CheckBoxTreeItem<FileNodeViewModel>) root).setSelected(true);
+            root.setExpanded(true);
+            EasyBind.listBind(viewModel.getCheckedFileList(), fileTreeView.getCheckModel().getCheckedItems());
+        });
+
+        new ViewModelTreeCellFactory<FileNodeViewModel>()
+                .withText(FileNodeViewModel::getDisplayText)
+                .install(fileTreeView);
+
+        texDirectoryField.textProperty().bindBidirectional(viewModel.texDirectoryProperty());
+        validationVisualizer.setDecoration(new IconValidationDecorator());
+        validationVisualizer.initVisualization(viewModel.texDirectoryValidation(), texDirectoryField);
+
+        browseButton.disableProperty().bindBidirectional(viewModel.searchInProgressProperty());
+        searchButton.disableProperty().bind(viewModel.texDirectoryValidation().validProperty().not());
+        selectAllButton.disableProperty().bindBidirectional(viewModel.noFilesFoundProperty());
+        unselectAllButton.disableProperty().bindBidirectional(viewModel.noFilesFoundProperty());
+
+        progressIndicator.visibleProperty().bindBidirectional(viewModel.searchInProgressProperty());
+    }
+
+    @FXML
+    private void browseButtonClicked() {
+        viewModel.browseButtonClicked();
+    }
+
+    @FXML
+    private void searchButtonClicked() {
+        viewModel.searchButtonClicked();
+    }
+
+    @FXML
+    private void selectAll() {
+        fileTreeView.getCheckModel().checkAll();
+    }
+
+    @FXML
+    private void unselectAll() {
+        fileTreeView.getCheckModel().clearChecks();
+    }
+}
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexDialogViewModel.java b/src/main/java/org/jabref/gui/texparser/ParseTexDialogViewModel.java
new file mode 100644
index 00000000000..eab42881f6f
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexDialogViewModel.java
@@ -0,0 +1,188 @@
+package org.jabref.gui.texparser;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.ReadOnlyListWrapper;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.scene.control.TreeItem;
+
+import org.jabref.gui.AbstractViewModel;
+import org.jabref.gui.DialogService;
+import org.jabref.gui.util.BackgroundTask;
+import org.jabref.gui.util.DirectoryDialogConfiguration;
+import org.jabref.gui.util.TaskExecutor;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.logic.texparser.DefaultTexParser;
+import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.preferences.PreferencesService;
+
+import de.saxsys.mvvmfx.utils.validation.FunctionBasedValidator;
+import de.saxsys.mvvmfx.utils.validation.ValidationMessage;
+import de.saxsys.mvvmfx.utils.validation.ValidationStatus;
+
+class ParseTexDialogViewModel extends AbstractViewModel {
+
+    private static final String TEX_EXT = ".tex";
+    private final DialogService dialogService;
+    private final TaskExecutor taskExecutor;
+    private final PreferencesService preferencesService;
+    private final StringProperty texDirectory;
+    private final FunctionBasedValidator texDirectoryValidator;
+    private final ObjectProperty<FileNodeViewModel> root;
+    private final ObservableList<TreeItem<FileNodeViewModel>> checkedFileList;
+    private final BooleanProperty noFilesFound;
+    private final BooleanProperty searchInProgress;
+    private final BooleanProperty successfulSearch;
+
+    public ParseTexDialogViewModel(BibDatabaseContext databaseContext, DialogService dialogService,
+                                   TaskExecutor taskExecutor, PreferencesService preferencesService) {
+        this.dialogService = dialogService;
+        this.taskExecutor = taskExecutor;
+        this.preferencesService = preferencesService;
+        this.texDirectory = new SimpleStringProperty(
+                databaseContext.getMetaData().getLaTexFileDirectory(preferencesService.getUser())
+                               .orElse(preferencesService.getWorkingDir())
+                               .toAbsolutePath().toString());
+        this.root = new SimpleObjectProperty<>();
+        this.checkedFileList = FXCollections.observableArrayList();
+        this.noFilesFound = new SimpleBooleanProperty(true);
+        this.searchInProgress = new SimpleBooleanProperty(false);
+        this.successfulSearch = new SimpleBooleanProperty(false);
+
+        Predicate<String> isDirectory = path -> Paths.get(path) != null && Paths.get(path).toFile().isDirectory();
+        texDirectoryValidator = new FunctionBasedValidator<>(texDirectory, isDirectory,
+                ValidationMessage.error(Localization.lang("Please enter a valid file path.")));
+    }
+
+    public StringProperty texDirectoryProperty() {
+        return texDirectory;
+    }
+
+    public ValidationStatus texDirectoryValidation() {
+        return texDirectoryValidator.getValidationStatus();
+    }
+
+    public ObjectProperty<FileNodeViewModel> rootProperty() {
+        return root;
+    }
+
+    public ObservableList<TreeItem<FileNodeViewModel>> getCheckedFileList() {
+        return new ReadOnlyListWrapper<>(checkedFileList);
+    }
+
+    public BooleanProperty noFilesFoundProperty() {
+        return noFilesFound;
+    }
+
+    public BooleanProperty searchInProgressProperty() {
+        return searchInProgress;
+    }
+
+    public BooleanProperty successfulSearchProperty() {
+        return successfulSearch;
+    }
+
+    public void browseButtonClicked() {
+        DirectoryDialogConfiguration directoryDialogConfiguration = new DirectoryDialogConfiguration.Builder()
+                .withInitialDirectory(Paths.get(texDirectory.get())).build();
+
+        dialogService.showDirectorySelectionDialog(directoryDialogConfiguration).ifPresent(selectedDirectory -> {
+            texDirectory.set(selectedDirectory.toAbsolutePath().toString());
+            preferencesService.setWorkingDir(selectedDirectory.toAbsolutePath());
+        });
+    }
+
+    /**
+     * Run a recursive search in a background task.
+     */
+    public void searchButtonClicked() {
+        BackgroundTask.wrap(() -> searchDirectory(Paths.get(texDirectory.get())))
+                      .onRunning(() -> {
+                          root.set(null);
+                          noFilesFound.set(true);
+                          searchInProgress.set(true);
+                          successfulSearch.set(false);
+
+                      })
+                      .onFinished(() -> searchInProgress.set(false))
+                      .onSuccess(newRoot -> {
+                          root.set(newRoot);
+                          noFilesFound.set(false);
+                          successfulSearch.set(true);
+                      })
+                      .onFailure(dialogService::showErrorDialogAndWait)
+                      .executeWith(taskExecutor);
+    }
+
+    private FileNodeViewModel searchDirectory(Path directory) throws IOException {
+        if (directory == null || !directory.toFile().exists() || !directory.toFile().isDirectory()) {
+            throw new IOException("An error occurred while searching an invalid directory.");
+        }
+
+        FileNodeViewModel parent = new FileNodeViewModel(directory);
+        Map<Boolean, List<Path>> fileListPartition;
+
+        try (Stream<Path> filesStream = Files.list(directory)) {
+            fileListPartition = filesStream.collect(Collectors.partitioningBy(path -> path.toFile().isDirectory()));
+        } catch (IOException e) {
+            throw new IOException("An error occurred while searching files: ", e);
+        }
+
+        List<Path> subDirectories = fileListPartition.get(true);
+        List<Path> files = fileListPartition.get(false)
+                                            .stream()
+                                            .filter(path -> path.toString().endsWith(TEX_EXT))
+                                            .collect(Collectors.toList());
+        int fileCount = 0;
+
+        for (Path subDirectory : subDirectories) {
+            FileNodeViewModel subRoot = searchDirectory(subDirectory);
+
+            if (subRoot != null && !subRoot.getChildren().isEmpty()) {
+                fileCount += subRoot.getFileCount();
+                parent.getChildren().add(subRoot);
+            }
+        }
+
+        parent.setFileCount(files.size() + fileCount);
+        parent.getChildren().addAll(files.stream()
+                                         .map(FileNodeViewModel::new)
+                                         .collect(Collectors.toList()));
+        return parent;
+    }
+
+    /**
+     * Parse all checked files in a background task.
+     */
+    public void parseButtonClicked() {
+        List<Path> fileList = checkedFileList.stream()
+                                             .map(item -> item.getValue().getPath().toAbsolutePath())
+                                             .filter(path -> path != null && path.toFile().isFile())
+                                             .collect(Collectors.toList());
+        if (fileList.isEmpty()) {
+            return;
+        }
+
+        BackgroundTask.wrap(() -> new DefaultTexParser().parse(fileList))
+                      .onRunning(() -> searchInProgress.set(true))
+                      .onFinished(() -> searchInProgress.set(false))
+                      .onSuccess(result -> new ParseTexResultView(result).showAndWait())
+                      .onFailure(dialogService::showErrorDialogAndWait)
+                      .executeWith(taskExecutor);
+    }
+}
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexResult.css b/src/main/java/org/jabref/gui/texparser/ParseTexResult.css
new file mode 100644
index 00000000000..2b17b3ca7c9
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexResult.css
@@ -0,0 +1,16 @@
+.list-view .list-cell {
+    -fx-padding: 10px;
+}
+
+.list-view .list-cell .contextBox {
+    -fx-border-color: grey;
+    -fx-border-style: dashed;
+    -fx-border-width: 2px;
+    -fx-font-size: 110%;
+    -fx-font-style: italic;
+    -fx-padding: 15px;
+}
+
+.list-view .list-cell .fileData {
+    -fx-font-family: 'Courier New', Courier, monospace;
+}
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexResult.fxml b/src/main/java/org/jabref/gui/texparser/ParseTexResult.fxml
new file mode 100644
index 00000000000..727f4f3a059
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexResult.fxml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<?import javafx.scene.control.ButtonType?>
+<?import javafx.scene.control.DialogPane?>
+<?import javafx.scene.control.ListView?>
+<?import javafx.scene.layout.HBox?>
+<?import javafx.scene.layout.VBox?>
+
+<DialogPane xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1"
+            fx:controller="org.jabref.gui.texparser.ParseTexResultView"
+            prefWidth="900.0" prefHeight="600.0">
+    <content>
+        <VBox spacing="10.0">
+            <HBox spacing="10.0" VBox.vgrow="ALWAYS">
+                <ListView fx:id="referenceListView" prefWidth="200.0"/>
+                <ListView fx:id="citationListView" HBox.hgrow="ALWAYS"/>
+            </HBox>
+        </VBox>
+    </content>
+    <ButtonType fx:constant="CLOSE"/>
+</DialogPane>
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexResultView.java b/src/main/java/org/jabref/gui/texparser/ParseTexResultView.java
new file mode 100644
index 00000000000..c9add05e9b1
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexResultView.java
@@ -0,0 +1,69 @@
+package org.jabref.gui.texparser;
+
+import javafx.fxml.FXML;
+import javafx.scene.control.ListView;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.scene.text.Text;
+
+import org.jabref.gui.util.BaseDialog;
+import org.jabref.gui.util.ViewModelListCellFactory;
+import org.jabref.logic.l10n.Localization;
+import org.jabref.model.strings.LatexToUnicodeAdapter;
+import org.jabref.model.texparser.Citation;
+import org.jabref.model.texparser.TexParserResult;
+
+import com.airhacks.afterburner.views.ViewLoader;
+import org.fxmisc.easybind.EasyBind;
+
+public class ParseTexResultView extends BaseDialog<Void> {
+
+    private final TexParserResult texParserResult;
+    @FXML private ListView<ReferenceViewModel> referenceListView;
+    @FXML private ListView<Citation> citationListView;
+    private ParseTexResultViewModel viewModel;
+
+    public ParseTexResultView(TexParserResult texParserResult) {
+        this.texParserResult = texParserResult;
+
+        this.setTitle(Localization.lang("LaTeX references search results"));
+
+        ViewLoader.view(this)
+                  .load()
+                  .setAsDialogPane(this);
+    }
+
+    @FXML
+    private void initialize() {
+        viewModel = new ParseTexResultViewModel(texParserResult);
+
+        referenceListView.setItems(viewModel.getReferenceList());
+        EasyBind.subscribe(referenceListView.getSelectionModel().selectedItemProperty(),
+                viewModel::activeReferenceChanged);
+        referenceListView.getSelectionModel().selectFirst();
+        new ViewModelListCellFactory<ReferenceViewModel>()
+                .withText(ReferenceViewModel::getDisplayText)
+                .install(referenceListView);
+
+        citationListView.setItems(viewModel.getCitationListByReference());
+        new ViewModelListCellFactory<Citation>()
+                .withGraphic(this::citationToGraphic)
+                .install(citationListView);
+    }
+
+    private VBox citationToGraphic(Citation item) {
+        String contextString = LatexToUnicodeAdapter.format(item.getLineText());
+        String fileDataString = String.format("%n%s (%s:%s-%s)%n", item.getPath().getFileName(), item.getLine(),
+                item.getColStart(), item.getColEnd());
+
+        Text context = new Text(contextString);
+        context.setWrappingWidth(citationListView.getWidth() - 50.0);
+        HBox contextBox = new HBox(context);
+        contextBox.getStyleClass().add("contextBox");
+
+        Text fileData = new Text(fileDataString);
+        fileData.getStyleClass().add("fileData");
+
+        return new VBox(contextBox, fileData);
+    }
+}
diff --git a/src/main/java/org/jabref/gui/texparser/ParseTexResultViewModel.java b/src/main/java/org/jabref/gui/texparser/ParseTexResultViewModel.java
new file mode 100644
index 00000000000..b3b6dbb77cf
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ParseTexResultViewModel.java
@@ -0,0 +1,43 @@
+package org.jabref.gui.texparser;
+
+import javafx.beans.property.ReadOnlyListWrapper;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+import org.jabref.gui.AbstractViewModel;
+import org.jabref.model.texparser.Citation;
+import org.jabref.model.texparser.TexParserResult;
+
+class ParseTexResultViewModel extends AbstractViewModel {
+
+    private final ObservableList<ReferenceViewModel> referenceList;
+    private final ObservableList<Citation> citationList;
+
+    public ParseTexResultViewModel(TexParserResult texParserResult) {
+        this.referenceList = FXCollections.observableArrayList();
+        this.citationList = FXCollections.observableArrayList();
+
+        texParserResult.getCitations()
+                       .asMap()
+                       .forEach((entry, citations) -> referenceList.add(new ReferenceViewModel(entry, citations)));
+    }
+
+    public ObservableList<ReferenceViewModel> getReferenceList() {
+        return new ReadOnlyListWrapper<>(referenceList);
+    }
+
+    public ObservableList<Citation> getCitationListByReference() {
+        return new ReadOnlyListWrapper<>(citationList);
+    }
+
+    /**
+     * Update the citation list depending on the selected reference.
+     */
+    public void activeReferenceChanged(ReferenceViewModel reference) {
+        if (reference == null) {
+            citationList.clear();
+        } else {
+            citationList.setAll(reference.getCitationList());
+        }
+    }
+}
diff --git a/src/main/java/org/jabref/gui/texparser/ReferenceViewModel.java b/src/main/java/org/jabref/gui/texparser/ReferenceViewModel.java
new file mode 100644
index 00000000000..7a2d3fcdba3
--- /dev/null
+++ b/src/main/java/org/jabref/gui/texparser/ReferenceViewModel.java
@@ -0,0 +1,42 @@
+package org.jabref.gui.texparser;
+
+import java.util.Collection;
+import java.util.StringJoiner;
+
+import javafx.beans.property.ReadOnlyListWrapper;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+
+import org.jabref.model.texparser.Citation;
+
+class ReferenceViewModel {
+
+    private final String entry;
+    private final ObservableList<Citation> citationList;
+
+    public ReferenceViewModel(String entry, Collection<Citation> citationColl) {
+        this.entry = entry;
+        this.citationList = FXCollections.observableArrayList();
+
+        citationList.setAll(citationColl);
+    }
+
+    public ObservableList<Citation> getCitationList() {
+        return new ReadOnlyListWrapper<>(citationList);
+    }
+
+    /**
+     * Return a string for displaying an entry key and its number of uses.
+     */
+    public String getDisplayText() {
+        return String.format("%s (%s)", entry, citationList.size());
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", ReferenceViewModel.class.getSimpleName() + "[", "]")
+                .add("entry='" + entry + "'")
+                .add("citationList=" + citationList)
+                .toString();
+    }
+}
diff --git a/src/main/java/org/jabref/gui/util/RecursiveTreeItem.java b/src/main/java/org/jabref/gui/util/RecursiveTreeItem.java
index c8c1f9db4ce..e86b791fd01 100644
--- a/src/main/java/org/jabref/gui/util/RecursiveTreeItem.java
+++ b/src/main/java/org/jabref/gui/util/RecursiveTreeItem.java
@@ -11,13 +11,17 @@
 import javafx.collections.ObservableList;
 import javafx.collections.transformation.FilteredList;
 import javafx.scene.Node;
-import javafx.scene.control.TreeItem;
+import javafx.scene.control.CheckBoxTreeItem;
 import javafx.util.Callback;
 
 /**
  * Taken from https://gist.github.com/lestard/011e9ed4433f9eb791a8
  */
-public class RecursiveTreeItem<T> extends TreeItem<T> {
+
+/**
+ * @implNote As CheckBoxTreeItem extends TreeItem, this class will work for both.
+ */
+public class RecursiveTreeItem<T> extends CheckBoxTreeItem<T> {
 
     private final Callback<T, BooleanProperty> expandedProperty;
     private Callback<T, ObservableList<T>> childrenFactory;
diff --git a/src/main/java/org/jabref/logic/texparser/DefaultTexParser.java b/src/main/java/org/jabref/logic/texparser/DefaultTexParser.java
new file mode 100644
index 00000000000..6b103d97243
--- /dev/null
+++ b/src/main/java/org/jabref/logic/texparser/DefaultTexParser.java
@@ -0,0 +1,137 @@
+package org.jabref.logic.texparser;
+
+import java.io.IOException;
+import java.io.LineNumberReader;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import org.jabref.model.texparser.TexParser;
+import org.jabref.model.texparser.TexParserResult;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class DefaultTexParser implements TexParser {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(DefaultTexParser.class);
+
+    /**
+     * It is allowed to add new cite commands for pattern matching.
+     *
+     * <p>Some valid examples: "citep", "[cC]ite", "[cC]ite(author|title|year|t|p)?"
+     *
+     * <p>TODO: Add support for multicite commands.
+     */
+    private static final String[] CITE_COMMANDS = {
+            "[cC]ite(alt|alp|author|authorfull|date|num|p|t|text|title|url|year|yearpar)?",
+            "([aA]|fnote|foot|footfull|full|no|[nN]ote|[pP]aren|[pP]note|[tT]ext|[sS]mart|super)cite",
+            "footcitetext"
+    };
+    private static final String CITE_GROUP = "key";
+    private static final Pattern CITE_PATTERN = Pattern.compile(
+            String.format("\\\\(%s)\\*?(?:\\[(?:[^\\]]*)\\]){0,2}\\{(?<%s>[^\\}]*)\\}",
+                    String.join("|", CITE_COMMANDS), CITE_GROUP));
+
+    private static final String INCLUDE_GROUP = "file";
+    private static final Pattern INCLUDE_PATTERN = Pattern.compile(
+            String.format("\\\\(?:include|input)\\{(?<%s>[^\\}]*)\\}", INCLUDE_GROUP));
+
+    private static final String TEX_EXT = ".tex";
+
+    private final TexParserResult result;
+
+    public DefaultTexParser() {
+        this.result = new TexParserResult();
+    }
+
+    public TexParserResult getResult() {
+        return result;
+    }
+
+    @Override
+    public TexParserResult parse(String citeString) {
+        matchCitation(Paths.get("foo/bar"), 1, citeString);
+        return result;
+    }
+
+    @Override
+    public TexParserResult parse(Path texFile) {
+        return parse(Collections.singletonList(texFile));
+    }
+
+    @Override
+    public TexParserResult parse(List<Path> texFiles) {
+        List<Path> referencedFiles = new ArrayList<>();
+
+        result.addFiles(texFiles);
+
+        for (Path file : texFiles) {
+            try (LineNumberReader lnr = new LineNumberReader(Files.newBufferedReader(file))) {
+                for (String line = lnr.readLine(); line != null; line = lnr.readLine()) {
+                    if (line.isEmpty() || line.charAt(0) == '%') {
+                        // Skip comments and blank lines.
+                        continue;
+                    }
+
+                    matchCitation(file, lnr.getLineNumber(), line);
+                    matchNestedFile(file, texFiles, referencedFiles, line);
+                }
+            } catch (IOException e) {
+                LOGGER.warn("Error opening the TEX file", e);
+            }
+        }
+
+        // Parse all files referenced by TEX files, recursively.
+        if (!referencedFiles.isEmpty()) {
+            parse(referencedFiles);
+        }
+
+        return result;
+    }
+
+    /**
+     * Find cites along a specific line and store them.
+     */
+    private void matchCitation(Path file, int lineNumber, String line) {
+        Matcher citeMatch = CITE_PATTERN.matcher(line);
+
+        while (citeMatch.find()) {
+            String[] keys = citeMatch.group(CITE_GROUP).split(",");
+
+            for (String key : keys) {
+                result.addKey(key, file, lineNumber, citeMatch.start(), citeMatch.end(), line);
+            }
+        }
+    }
+
+    /**
+     * Find inputs and includes along a specific line and store them for parsing later.
+     */
+    private void matchNestedFile(Path file, List<Path> texFiles, List<Path> referencedFiles, String line) {
+        Matcher includeMatch = INCLUDE_PATTERN.matcher(line);
+        StringBuilder include;
+
+        while (includeMatch.find()) {
+            include = new StringBuilder(includeMatch.group(INCLUDE_GROUP));
+
+            if (!include.toString().endsWith(TEX_EXT)) {
+                include.append(TEX_EXT);
+            }
+
+            Path folder = file.getParent();
+            Path inputFile = (folder == null)
+                    ? Paths.get(include.toString())
+                    : folder.resolve(include.toString());
+
+            if (!texFiles.contains(inputFile)) {
+                referencedFiles.add(inputFile);
+            }
+        }
+    }
+}
diff --git a/src/main/java/org/jabref/logic/texparser/TexBibEntriesResolver.java b/src/main/java/org/jabref/logic/texparser/TexBibEntriesResolver.java
new file mode 100644
index 00000000000..d32bc9c7289
--- /dev/null
+++ b/src/main/java/org/jabref/logic/texparser/TexBibEntriesResolver.java
@@ -0,0 +1,61 @@
+package org.jabref.logic.texparser;
+
+import java.util.Optional;
+import java.util.Set;
+
+import org.jabref.model.database.BibDatabase;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.FieldName;
+import org.jabref.model.texparser.TexBibEntriesResolverResult;
+import org.jabref.model.texparser.TexParserResult;
+
+public class TexBibEntriesResolver {
+
+    private final BibDatabase masterDatabase;
+
+    public TexBibEntriesResolver(BibDatabase masterDatabase) {
+        this.masterDatabase = masterDatabase;
+    }
+
+    /**
+     * Look for BibTeX entries within the reference database for all keys inside of the TEX files.
+     * Insert these data in the list of new entries.
+     */
+    public TexBibEntriesResolverResult resolveKeys(TexParserResult texParserResult) {
+        TexBibEntriesResolverResult result = new TexBibEntriesResolverResult(texParserResult);
+        Set<String> keySet = result.getCitationsKeySet();
+
+        for (String key : keySet) {
+            if (!result.checkEntryNewDatabase(key)) {
+                Optional<BibEntry> entry = masterDatabase.getEntryByKey(key);
+
+                if (entry.isPresent()) {
+                    result.insertEntry(entry.get());
+                    resolveCrossReferences(result, entry.get());
+                } else {
+                    result.addUnresolvedKey(key);
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Find cross references for inserting into the list of new entries.
+     */
+    private void resolveCrossReferences(TexBibEntriesResolverResult result, BibEntry entry) {
+        entry.getField(FieldName.CROSSREF).ifPresent(crossRef -> {
+            if (!result.checkEntryNewDatabase(crossRef)) {
+                Optional<BibEntry> refEntry = masterDatabase.getEntryByKey(crossRef);
+
+                if (refEntry.isPresent()) {
+                    result.insertEntry(refEntry.get());
+                    result.increaseCrossRefsCount();
+                } else {
+                    result.addUnresolvedKey(crossRef);
+                }
+            }
+        });
+    }
+}
diff --git a/src/main/java/org/jabref/logic/util/StandardFileType.java b/src/main/java/org/jabref/logic/util/StandardFileType.java
index 0d62f73ef65..9bb7bd3a9f8 100644
--- a/src/main/java/org/jabref/logic/util/StandardFileType.java
+++ b/src/main/java/org/jabref/logic/util/StandardFileType.java
@@ -35,6 +35,7 @@ public enum StandardFileType implements FileType {
     RDF("rdf"),
     RTF("rtf"),
     SXC("sxc"),
+    TEX("tex"),
     XML("xml"),
     JSON("json"),
     XMP("xmp"),
diff --git a/src/main/java/org/jabref/model/texparser/Citation.java b/src/main/java/org/jabref/model/texparser/Citation.java
new file mode 100644
index 00000000000..24f9a503873
--- /dev/null
+++ b/src/main/java/org/jabref/model/texparser/Citation.java
@@ -0,0 +1,113 @@
+package org.jabref.model.texparser;
+
+import java.nio.file.Path;
+import java.util.Objects;
+import java.util.StringJoiner;
+
+public class Citation {
+
+    /**
+     * The total number of characters that are shown around a cite (cite width included).
+     */
+    private static final int CONTEXT_WIDTH = 200;
+
+    private final Path path;
+    private final int line;
+    private final int colStart;
+    private final int colEnd;
+    private final String lineText;
+
+    public Citation(Path path, int line, int colStart, int colEnd, String lineText) {
+        if (path == null) {
+            throw new IllegalArgumentException("Path cannot be null.");
+        }
+
+        if (line <= 0) {
+            throw new IllegalArgumentException("Line has to be greater than 0.");
+        }
+
+        if (colStart < 0 || colEnd > lineText.length()) {
+            throw new IllegalArgumentException("Citation has to be between 0 and line length.");
+        }
+
+        this.path = path;
+        this.line = line;
+        this.colStart = colStart;
+        this.colEnd = colEnd;
+        this.lineText = lineText;
+    }
+
+    public Path getPath() {
+        return path;
+    }
+
+    public int getLine() {
+        return line;
+    }
+
+    public int getColStart() {
+        return colStart;
+    }
+
+    public int getColEnd() {
+        return colEnd;
+    }
+
+    public String getLineText() {
+        return lineText;
+    }
+
+    public int getContextWidth() {
+        return CONTEXT_WIDTH;
+    }
+
+    /**
+     * Get a fixed-width string that contains a cite and the text that surrounds it along the same line.
+     */
+    public String getContext() {
+        int center = (colStart + colEnd) / 2;
+        int lineLength = lineText.length();
+
+        int start = Math.max(0, (center + CONTEXT_WIDTH / 2 < lineLength)
+                ? center - CONTEXT_WIDTH / 2
+                : lineLength - CONTEXT_WIDTH);
+        int end = Math.min(lineLength, start + CONTEXT_WIDTH);
+
+        return lineText.substring(start, end);
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", getClass().getSimpleName() + "[", "]")
+                .add("path = " + path)
+                .add("line = " + line)
+                .add("colStart = " + colStart)
+                .add("colEnd = " + colEnd)
+                .add("lineText = " + lineText)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        Citation that = (Citation) o;
+
+        return Objects.equals(path, that.path)
+                && Objects.equals(line, that.line)
+                && Objects.equals(colStart, that.colStart)
+                && Objects.equals(colEnd, that.colEnd)
+                && Objects.equals(lineText, that.lineText);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(path, line, colStart, colEnd, lineText);
+    }
+}
diff --git a/src/main/java/org/jabref/model/texparser/TexBibEntriesResolverResult.java b/src/main/java/org/jabref/model/texparser/TexBibEntriesResolverResult.java
new file mode 100644
index 00000000000..e8602d119cb
--- /dev/null
+++ b/src/main/java/org/jabref/model/texparser/TexBibEntriesResolverResult.java
@@ -0,0 +1,125 @@
+package org.jabref.model.texparser;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.StringJoiner;
+
+import org.jabref.model.database.BibDatabase;
+import org.jabref.model.entry.BibEntry;
+
+import com.google.common.collect.Multimap;
+
+public class TexBibEntriesResolverResult {
+
+    private final TexParserResult texParserResult;
+    private final List<String> unresolvedKeys;
+    private final List<BibEntry> newEntries;
+    private int crossRefsCount;
+
+    public TexBibEntriesResolverResult(TexParserResult texParserResult) {
+        this.texParserResult = texParserResult;
+        this.unresolvedKeys = new ArrayList<>();
+        this.newEntries = new ArrayList<>();
+        this.crossRefsCount = 0;
+    }
+
+    public TexParserResult getTexParserResult() {
+        return texParserResult;
+    }
+
+    public List<String> getUnresolvedKeys() {
+        return unresolvedKeys;
+    }
+
+    public List<BibEntry> getNewEntries() {
+        return newEntries;
+    }
+
+    public int getCrossRefsCount() {
+        return crossRefsCount;
+    }
+
+    /**
+     * Return the citations multimap from the TexParserResult object.
+     */
+    public Multimap<String, Citation> getCitations() {
+        return texParserResult.getCitations();
+    }
+
+    /**
+     * Return a set of strings with the keys of the citations multimap from the TexParserResult object.
+     */
+    public Set<String> getCitationsKeySet() {
+        return texParserResult.getCitationsKeySet();
+    }
+
+    /**
+     * Add an unresolved key to the list.
+     */
+    public void addUnresolvedKey(String key) {
+        unresolvedKeys.add(key);
+    }
+
+    /**
+     * Check if an entry with the given key is present in the list of new entries.
+     */
+    public boolean checkEntryNewDatabase(String key) {
+        return newEntries.stream().anyMatch(entry -> key.equals(entry.getCiteKeyOptional().orElse(null)));
+    }
+
+    /**
+     * Add 1 to the cross references counter.
+     */
+    public void increaseCrossRefsCount() {
+        crossRefsCount++;
+    }
+
+    /**
+     * Insert into the list of new entries an entry with the given key.
+     */
+    public void insertEntry(BibDatabase masterDatabase, String key) {
+        masterDatabase.getEntryByKey(key).ifPresent(this::insertEntry);
+    }
+
+    /**
+     * Insert into the list of new entries the given entry.
+     */
+    public void insertEntry(BibEntry entry) {
+        newEntries.add(entry);
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", this.getClass().getSimpleName() + "[", "]")
+                .add("texParserResult = " + texParserResult)
+                .add("unresolvedKeys = " + unresolvedKeys)
+                .add("newEntries = " + newEntries)
+                .add("crossRefsCount = " + crossRefsCount)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        TexBibEntriesResolverResult that = (TexBibEntriesResolverResult) o;
+
+        return Objects.equals(texParserResult, that.texParserResult)
+                && Objects.equals(unresolvedKeys, that.unresolvedKeys)
+                && Objects.equals(newEntries, that.newEntries)
+                && Objects.equals(crossRefsCount, that.crossRefsCount);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(texParserResult, unresolvedKeys, newEntries, crossRefsCount);
+    }
+}
diff --git a/src/main/java/org/jabref/model/texparser/TexParser.java b/src/main/java/org/jabref/model/texparser/TexParser.java
new file mode 100644
index 00000000000..45ed93b8c1e
--- /dev/null
+++ b/src/main/java/org/jabref/model/texparser/TexParser.java
@@ -0,0 +1,31 @@
+package org.jabref.model.texparser;
+
+import java.nio.file.Path;
+import java.util.List;
+
+public interface TexParser {
+
+    /**
+     * For testing purposes.
+     *
+     * @param citeString String that contains a citation
+     * @return a TexParserResult, where Path is foo/bar and lineNumber is 1
+     */
+    TexParserResult parse(String citeString);
+
+    /**
+     * Parse a single TEX file.
+     *
+     * @param texFile Path to a TEX file
+     * @return a TexParserResult, which contains all data related to the bibliographic entries
+     */
+    TexParserResult parse(Path texFile);
+
+    /**
+     * Parse a list of TEX files.
+     *
+     * @param texFiles List of Path objects linked to a TEX file
+     * @return a TexParserResult, which contains all data related to the bibliographic entries
+     */
+    TexParserResult parse(List<Path> texFiles);
+}
diff --git a/src/main/java/org/jabref/model/texparser/TexParserResult.java b/src/main/java/org/jabref/model/texparser/TexParserResult.java
new file mode 100644
index 00000000000..043ca473c68
--- /dev/null
+++ b/src/main/java/org/jabref/model/texparser/TexParserResult.java
@@ -0,0 +1,101 @@
+package org.jabref.model.texparser;
+
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.StringJoiner;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Multimap;
+
+public class TexParserResult {
+
+    private final List<Path> fileList;
+    private final List<Path> nestedFiles;
+    private final Multimap<String, Citation> citations;
+
+    public TexParserResult() {
+        this.fileList = new ArrayList<>();
+        this.nestedFiles = new ArrayList<>();
+        this.citations = HashMultimap.create();
+    }
+
+    public List<Path> getFileList() {
+        return fileList;
+    }
+
+    public List<Path> getNestedFiles() {
+        return nestedFiles;
+    }
+
+    public Multimap<String, Citation> getCitations() {
+        return citations;
+    }
+
+    /**
+     * Return a set of strings with the keys of the citations multimap.
+     */
+    public Set<String> getCitationsKeySet() {
+        return citations.keySet();
+    }
+
+    /**
+     * Return a collection of citations using a string as key reference.
+     */
+    public Collection<Citation> getCitationsByKey(String key) {
+        return citations.get(key);
+    }
+
+    /**
+     * Add a list of files to fileList or nestedFiles, depending on whether this is the first list.
+     */
+    public void addFiles(List<Path> texFiles) {
+        if (fileList.isEmpty()) {
+            fileList.addAll(texFiles);
+        } else {
+            nestedFiles.addAll(texFiles);
+        }
+    }
+
+    /**
+     * Add a citation to the citations multimap.
+     */
+    public void addKey(String key, Path file, int lineNumber, int start, int end, String line) {
+        Citation citation = new Citation(file, lineNumber, start, end, line);
+        citations.put(key, citation);
+    }
+
+    @Override
+    public String toString() {
+        return new StringJoiner(", ", getClass().getSimpleName() + "[", "]")
+                .add("fileList = " + fileList)
+                .add("nestedFiles = " + nestedFiles)
+                .add("citations = " + citations)
+                .toString();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+
+        TexParserResult that = (TexParserResult) o;
+
+        return Objects.equals(fileList, that.fileList)
+                && Objects.equals(nestedFiles, that.nestedFiles)
+                && Objects.equals(citations, that.citations);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(fileList, nestedFiles, citations);
+    }
+}
diff --git a/src/main/resources/l10n/JabRef_en.properties b/src/main/resources/l10n/JabRef_en.properties
index bae2e82011d..19f704a085e 100644
--- a/src/main/resources/l10n/JabRef_en.properties
+++ b/src/main/resources/l10n/JabRef_en.properties
@@ -2094,3 +2094,9 @@ Import\ BibTeX=Import BibTeX
 Import\ preferences\ from\ a\ file=Import preferences from a file
 Matching=Matching
 Same\ as\ --import,\ but\ will\ be\ imported\ to\ the\ opened\ tab=Same as --import, but will be imported to the opened tab
+
+LaTeX\ references\ search=LaTeX references search
+LaTeX\ references\ search\ results=LaTeX references search results
+LaTeX\ files\ directory\:=LaTeX files directory:
+LaTeX\ files\ found\:=LaTeX files found:
+files=files
diff --git a/src/test/java/org/jabref/logic/texparser/DefaultTexParserTest.java b/src/test/java/org/jabref/logic/texparser/DefaultTexParserTest.java
new file mode 100644
index 00000000000..961fd9339b0
--- /dev/null
+++ b/src/test/java/org/jabref/logic/texparser/DefaultTexParserTest.java
@@ -0,0 +1,165 @@
+package org.jabref.logic.texparser;
+
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+import org.jabref.model.texparser.TexParserResult;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class DefaultTexParserTest {
+    private final static String DARWIN = "Darwin1888";
+    private final static String EINSTEIN = "Einstein1920";
+    private final static String NEWTON = "Newton1999";
+    private final static String EINSTEIN_A = "Einstein1920a";
+    private final static String EINSTEIN_B = "Einstein1920b";
+    private final static String EINSTEIN_C = "Einstein1920c";
+    private final static String EINSTEIN_21 = "Einstein1921";
+    private final static String UNRESOLVED = "UnresolvedKey";
+    private final static String UNKNOWN = "UnknownKey";
+
+    private void testMatchCite(String key, String citeString) {
+        TexParserResult texParserResult = new DefaultTexParser().parse(citeString);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.addKey(key, Paths.get("foo/bar"), 1, 0, citeString.length(), citeString);
+
+        assertEquals(expectedParserResult, texParserResult);
+    }
+
+    private void testNonMatchCite(String citeString) {
+        TexParserResult texParserResult = new DefaultTexParser().parse(citeString);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        assertEquals(expectedParserResult, texParserResult);
+    }
+
+    @Test
+    public void testCiteCommands() {
+        testMatchCite(UNRESOLVED, "\\cite[pre][post]{UnresolvedKey}");
+        testMatchCite(UNRESOLVED, "\\cite*{UnresolvedKey}");
+        testMatchCite(UNRESOLVED, "\\parencite[post]{UnresolvedKey}");
+        testMatchCite(UNRESOLVED, "\\cite[pre][post]{UnresolvedKey}");
+        testMatchCite(EINSTEIN_C, "\\citep{Einstein1920c}");
+
+        testNonMatchCite("\\citet21312{123U123n123resolvedKey}");
+        testNonMatchCite("\\1cite[pr234e][post]{UnresolvedKey}");
+        testNonMatchCite("\\citep55{5}UnresolvedKey}");
+        testNonMatchCite("\\cit2et{UnresolvedKey}");
+    }
+
+    @Test
+    public void testTwoCitationsSameLine() {
+        String citeString = "\\citep{Einstein1920c} and \\citep{Einstein1920a}";
+
+        TexParserResult texParserResult = new DefaultTexParser().parse(citeString);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.addKey(EINSTEIN_C, Paths.get("foo/bar"), 1, 0, 21, citeString);
+        expectedParserResult.addKey(EINSTEIN_A, Paths.get("foo/bar"), 1, 26, 47, citeString);
+
+        assertEquals(expectedParserResult, texParserResult);
+    }
+
+    @Test
+    public void testSingleFile() throws URISyntaxException {
+        Path texFile = Paths.get(DefaultTexParserTest.class.getResource("paper.tex").toURI());
+
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().add(texFile);
+        expectedParserResult.addKey(EINSTEIN, texFile, 4, 0, 19, "\\cite{Einstein1920}");
+        expectedParserResult.addKey(DARWIN, texFile, 5, 0, 17, "\\cite{Darwin1888}.");
+        expectedParserResult.addKey(EINSTEIN, texFile, 6, 14, 33, "Einstein said \\cite{Einstein1920} that lorem impsum, consectetur adipiscing elit.");
+        expectedParserResult.addKey(DARWIN, texFile, 7, 67, 84, "Nunc ultricies leo nec libero rhoncus, eu vehicula enim efficitur. \\cite{Darwin1888}");
+
+        assertEquals(expectedParserResult, parserResult);
+    }
+
+    @Test
+    public void testTwoFiles() throws URISyntaxException {
+        Path texFile = Paths.get(DefaultTexParserTest.class.getResource("paper.tex").toURI());
+        Path texFile2 = Paths.get(DefaultTexParserTest.class.getResource("paper2.tex").toURI());
+
+        TexParserResult parserResult = new DefaultTexParser().parse(Arrays.asList(texFile, texFile2));
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().addAll(Arrays.asList(texFile, texFile2));
+        expectedParserResult.addKey(EINSTEIN, texFile, 4, 0, 19, "\\cite{Einstein1920}");
+        expectedParserResult.addKey(DARWIN, texFile, 5, 0, 17, "\\cite{Darwin1888}.");
+        expectedParserResult.addKey(EINSTEIN, texFile, 6, 14, 33, "Einstein said \\cite{Einstein1920} that lorem impsum, consectetur adipiscing elit.");
+        expectedParserResult.addKey(DARWIN, texFile, 7, 67, 84, "Nunc ultricies leo nec libero rhoncus, eu vehicula enim efficitur. \\cite{Darwin1888}");
+        expectedParserResult.addKey(DARWIN, texFile2, 4, 48, 65, "This is some content trying to cite a bib file: \\cite{Darwin1888}");
+        expectedParserResult.addKey(EINSTEIN, texFile2, 5, 48, 67, "This is some content trying to cite a bib file: \\cite{Einstein1920}");
+        expectedParserResult.addKey(NEWTON, texFile2, 6, 48, 65, "This is some content trying to cite a bib file: \\cite{Newton1999}");
+
+        assertEquals(expectedParserResult, parserResult);
+    }
+
+    @Test
+    public void testDuplicateFiles() throws URISyntaxException {
+        Path texFile = Paths.get(DefaultTexParserTest.class.getResource("paper.tex").toURI());
+
+        TexParserResult parserResult = new DefaultTexParser().parse(Arrays.asList(texFile, texFile));
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().addAll(Arrays.asList(texFile, texFile));
+        expectedParserResult.addKey(EINSTEIN, texFile, 4, 0, 19, "\\cite{Einstein1920}");
+        expectedParserResult.addKey(DARWIN, texFile, 5, 0, 17, "\\cite{Darwin1888}.");
+        expectedParserResult.addKey(EINSTEIN, texFile, 6, 14, 33, "Einstein said \\cite{Einstein1920} that lorem impsum, consectetur adipiscing elit.");
+        expectedParserResult.addKey(DARWIN, texFile, 7, 67, 84, "Nunc ultricies leo nec libero rhoncus, eu vehicula enim efficitur. \\cite{Darwin1888}");
+
+        assertEquals(expectedParserResult, parserResult);
+    }
+
+    @Test
+    public void testUnknownKey() throws URISyntaxException {
+        Path texFile = Paths.get(DefaultTexParserTest.class.getResource("unknown_key.tex").toURI());
+
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().add(texFile);
+        expectedParserResult.addKey(DARWIN, texFile, 4, 48, 65, "This is some content trying to cite a bib file: \\cite{Darwin1888}");
+        expectedParserResult.addKey(EINSTEIN, texFile, 5, 48, 67, "This is some content trying to cite a bib file: \\cite{Einstein1920}");
+        expectedParserResult.addKey(UNKNOWN, texFile, 6, 48, 65, "This is some content trying to cite a bib file: \\cite{UnknownKey}");
+
+        assertEquals(expectedParserResult, parserResult);
+    }
+
+    @Test
+    public void testFileNotFound() {
+        Path texFile = Paths.get("file_not_found.tex");
+
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().add(texFile);
+
+        assertEquals(expectedParserResult, parserResult);
+    }
+
+    @Test
+    public void testNestedFiles() throws URISyntaxException {
+        Path texFile = Paths.get(DefaultTexParserTest.class.getResource("nested.tex").toURI());
+        Path texFile2 = Paths.get(DefaultTexParserTest.class.getResource("nested2.tex").toURI());
+        Path texFile3 = Paths.get(DefaultTexParserTest.class.getResource("paper.tex").toURI());
+
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().add(texFile);
+        expectedParserResult.getNestedFiles().addAll(Arrays.asList(texFile2, texFile3));
+        expectedParserResult.addKey(EINSTEIN, texFile3, 4, 0, 19, "\\cite{Einstein1920}");
+        expectedParserResult.addKey(DARWIN, texFile3, 5, 0, 17, "\\cite{Darwin1888}.");
+        expectedParserResult.addKey(EINSTEIN, texFile3, 6, 14, 33, "Einstein said \\cite{Einstein1920} that lorem impsum, consectetur adipiscing elit.");
+        expectedParserResult.addKey(DARWIN, texFile3, 7, 67, 84, "Nunc ultricies leo nec libero rhoncus, eu vehicula enim efficitur. \\cite{Darwin1888}");
+
+        assertEquals(expectedParserResult, parserResult);
+    }
+}
diff --git a/src/test/java/org/jabref/logic/texparser/TexBibEntriesResolverTest.java b/src/test/java/org/jabref/logic/texparser/TexBibEntriesResolverTest.java
new file mode 100644
index 00000000000..3d33d7639bb
--- /dev/null
+++ b/src/test/java/org/jabref/logic/texparser/TexBibEntriesResolverTest.java
@@ -0,0 +1,170 @@
+package org.jabref.logic.texparser;
+
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+import org.jabref.model.database.BibDatabase;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibtexEntryTypes;
+import org.jabref.model.texparser.TexBibEntriesResolverResult;
+import org.jabref.model.texparser.TexParserResult;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TexBibEntriesResolverTest {
+    private final static String DARWIN = "Darwin1888";
+    private final static String EINSTEIN = "Einstein1920";
+    private final static String NEWTON = "Newton1999";
+    private final static String EINSTEIN_A = "Einstein1920a";
+    private final static String EINSTEIN_B = "Einstein1920b";
+    private final static String EINSTEIN_C = "Einstein1920c";
+    private final static String EINSTEIN_21 = "Einstein1921";
+    private final static String UNRESOLVED = "UnresolvedKey";
+    private final static String UNKNOWN = "UnknownKey";
+
+    private static BibDatabase database;
+
+    @BeforeEach
+    private void setUp() {
+        database = new BibDatabase();
+
+        BibEntry darwin = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", DARWIN)
+                .withField("title", "The descent of man, and selection in relation to sex")
+                .withField("publisher", "J. Murray")
+                .withField("year", "1888")
+                .withField("author", "Darwin, Charles");
+        database.insertEntry(darwin);
+
+        BibEntry einstein = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN)
+                .withField("title", "Relativity: The special and general theory")
+                .withField("publisher", "Penguin")
+                .withField("year", "1920")
+                .withField("author", "Einstein, Albert");
+        database.insertEntry(einstein);
+
+        BibEntry newton = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", NEWTON)
+                .withField("title", "The Principia: mathematical principles of natural philosophy")
+                .withField("publisher", "Univ of California Press")
+                .withField("year", "1999")
+                .withField("author", "Newton, Isaac");
+        database.insertEntry(newton);
+
+        BibEntry einsteinA = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN_A)
+                .withField("crossref", "Einstein1920")
+                .withField("pages", "22--23");
+        database.insertEntry(einsteinA);
+
+        BibEntry einsteinB = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN_B)
+                .withField("crossref", "Einstein1921")
+                .withField("pages", "22--23");
+        database.insertEntry(einsteinB);
+
+        BibEntry einsteinC = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN_C)
+                .withField("crossref", "Einstein1920")
+                .withField("pages", "25--33");
+        database.insertEntry(einsteinC);
+    }
+
+    @Test
+    public void testSingleFile() throws URISyntaxException {
+        Path texFile = Paths.get(TexBibEntriesResolverTest.class.getResource("paper.tex").toURI());
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(parserResult);
+
+        expectedCrossingResult.insertEntry(database, DARWIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+
+        assertEquals(expectedCrossingResult, crossingResult);
+    }
+
+    @Test
+    public void testTwoFiles() throws URISyntaxException {
+        Path texFile = Paths.get(TexBibEntriesResolverTest.class.getResource("paper.tex").toURI());
+        Path texFile2 = Paths.get(TexBibEntriesResolverTest.class.getResource("paper2.tex").toURI());
+        TexParserResult parserResult = new DefaultTexParser().parse(Arrays.asList(texFile, texFile2));
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(parserResult);
+
+        expectedCrossingResult.insertEntry(database, DARWIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+        expectedCrossingResult.insertEntry(database, NEWTON);
+
+        assertEquals(expectedCrossingResult, crossingResult);
+    }
+
+    @Test
+    public void testDuplicateFiles() throws URISyntaxException {
+        Path texFile = Paths.get(TexBibEntriesResolverTest.class.getResource("paper.tex").toURI());
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(parserResult);
+
+        expectedCrossingResult.insertEntry(database, DARWIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+
+        assertEquals(expectedCrossingResult, crossingResult);
+    }
+
+    @Test
+    public void testUnknownKey() throws URISyntaxException {
+        Path texFile = Paths.get(TexBibEntriesResolverTest.class.getResource("unknown_key.tex").toURI());
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(parserResult);
+
+        expectedCrossingResult.insertEntry(database, DARWIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+        expectedCrossingResult.addUnresolvedKey(UNKNOWN);
+
+        assertEquals(expectedCrossingResult, crossingResult);
+    }
+
+    @Test
+    public void testNestedFiles() throws URISyntaxException {
+        Path texFile = Paths.get(TexBibEntriesResolverTest.class.getResource("nested.tex").toURI());
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(parserResult);
+
+        expectedCrossingResult.insertEntry(database, DARWIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+
+        assertEquals(expectedCrossingResult, crossingResult);
+    }
+
+    @Test
+    public void testCrossRef() throws URISyntaxException {
+        Path texFile = Paths.get(TexBibEntriesResolverTest.class.getResource("crossref.tex").toURI());
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(parserResult);
+
+        expectedCrossingResult.insertEntry(database, EINSTEIN_B);
+        expectedCrossingResult.insertEntry(database, EINSTEIN_A);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN_C);
+        expectedCrossingResult.addUnresolvedKey(EINSTEIN_21);
+        expectedCrossingResult.addUnresolvedKey(UNRESOLVED);
+        expectedCrossingResult.increaseCrossRefsCount();
+
+        assertEquals(expectedCrossingResult, crossingResult);
+    }
+}
diff --git a/src/test/java/org/jabref/logic/texparser/TexParserTest.java b/src/test/java/org/jabref/logic/texparser/TexParserTest.java
new file mode 100644
index 00000000000..92ffd08988c
--- /dev/null
+++ b/src/test/java/org/jabref/logic/texparser/TexParserTest.java
@@ -0,0 +1,147 @@
+package org.jabref.logic.texparser;
+
+import java.net.URISyntaxException;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+
+import org.jabref.model.database.BibDatabase;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.BibtexEntryTypes;
+import org.jabref.model.texparser.TexBibEntriesResolverResult;
+import org.jabref.model.texparser.TexParserResult;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class TexParserTest {
+    private final static String DARWIN = "Darwin1888";
+    private final static String EINSTEIN = "Einstein1920";
+    private final static String NEWTON = "Newton1999";
+    private final static String EINSTEIN_A = "Einstein1920a";
+    private final static String EINSTEIN_B = "Einstein1920b";
+    private final static String EINSTEIN_C = "Einstein1920c";
+    private final static String EINSTEIN_21 = "Einstein1921";
+    private final static String UNRESOLVED = "UnresolvedKey";
+    private final static String UNKNOWN = "UnknownKey";
+
+    private static BibDatabase database;
+    private static BibDatabase database2;
+
+    @BeforeEach
+    private void setUp() {
+        database = new BibDatabase();
+        database2 = new BibDatabase();
+
+        BibEntry darwin = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", DARWIN)
+                .withField("title", "The descent of man, and selection in relation to sex")
+                .withField("publisher", "J. Murray")
+                .withField("year", "1888")
+                .withField("author", "Darwin, Charles");
+        database.insertEntry(darwin);
+
+        BibEntry einstein = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN)
+                .withField("title", "Relativity: The special and general theory")
+                .withField("publisher", "Penguin")
+                .withField("year", "1920")
+                .withField("author", "Einstein, Albert");
+        database.insertEntry(einstein);
+        database2.insertEntry(einstein);
+
+        BibEntry newton = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", NEWTON)
+                .withField("title", "The Principia: mathematical principles of natural philosophy")
+                .withField("publisher", "Univ of California Press")
+                .withField("year", "1999")
+                .withField("author", "Newton, Isaac");
+        database.insertEntry(newton);
+
+        BibEntry einsteinA = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN_A)
+                .withField("crossref", "Einstein1920")
+                .withField("pages", "22--23");
+        database.insertEntry(einsteinA);
+
+        BibEntry einsteinB = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN_B)
+                .withField("crossref", "Einstein1921")
+                .withField("pages", "22--23");
+        database.insertEntry(einsteinB);
+
+        BibEntry einsteinC = new BibEntry(BibtexEntryTypes.BOOK)
+                .withField("bibtexkey", EINSTEIN_C)
+                .withField("crossref", "Einstein1920")
+                .withField("pages", "25--33");
+        database.insertEntry(einsteinC);
+    }
+
+    @Test
+    public void testSameFileDifferentDatabases() throws URISyntaxException {
+        Path texFile = Paths.get(TexParserTest.class.getResource("paper.tex").toURI());
+
+        TexParserResult parserResult = new DefaultTexParser().parse(texFile);
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().add(texFile);
+        expectedParserResult.addKey(EINSTEIN, texFile, 4, 0, 19, "\\cite{Einstein1920}");
+        expectedParserResult.addKey(DARWIN, texFile, 5, 0, 17, "\\cite{Darwin1888}.");
+        expectedParserResult.addKey(EINSTEIN, texFile, 6, 14, 33, "Einstein said \\cite{Einstein1920} that lorem impsum, consectetur adipiscing elit.");
+        expectedParserResult.addKey(DARWIN, texFile, 7, 67, 84, "Nunc ultricies leo nec libero rhoncus, eu vehicula enim efficitur. \\cite{Darwin1888}");
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(expectedParserResult);
+
+        expectedCrossingResult.insertEntry(database, DARWIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+
+        assertEquals(expectedCrossingResult, crossingResult);
+
+        TexBibEntriesResolverResult crossingResult2 = new TexBibEntriesResolver(database2).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult2 = new TexBibEntriesResolverResult(expectedParserResult);
+
+        expectedCrossingResult2.insertEntry(database2, EINSTEIN);
+        expectedCrossingResult2.addUnresolvedKey(DARWIN);
+
+        assertEquals(expectedCrossingResult2, crossingResult2);
+    }
+
+    @Test
+    public void testTwoFilesDifferentDatabases() throws URISyntaxException {
+        Path texFile = Paths.get(TexParserTest.class.getResource("paper.tex").toURI());
+        Path texFile2 = Paths.get(TexParserTest.class.getResource("paper2.tex").toURI());
+
+        TexParserResult parserResult = new DefaultTexParser().parse(Arrays.asList(texFile, texFile2));
+        TexParserResult expectedParserResult = new TexParserResult();
+
+        expectedParserResult.getFileList().addAll(Arrays.asList(texFile, texFile2));
+        expectedParserResult.addKey(EINSTEIN, texFile, 4, 0, 19, "\\cite{Einstein1920}");
+        expectedParserResult.addKey(DARWIN, texFile, 5, 0, 17, "\\cite{Darwin1888}.");
+        expectedParserResult.addKey(EINSTEIN, texFile, 6, 14, 33, "Einstein said \\cite{Einstein1920} that lorem impsum, consectetur adipiscing elit.");
+        expectedParserResult.addKey(DARWIN, texFile, 7, 67, 84, "Nunc ultricies leo nec libero rhoncus, eu vehicula enim efficitur. \\cite{Darwin1888}");
+        expectedParserResult.addKey(DARWIN, texFile2, 4, 48, 65, "This is some content trying to cite a bib file: \\cite{Darwin1888}");
+        expectedParserResult.addKey(EINSTEIN, texFile2, 5, 48, 67, "This is some content trying to cite a bib file: \\cite{Einstein1920}");
+        expectedParserResult.addKey(NEWTON, texFile2, 6, 48, 65, "This is some content trying to cite a bib file: \\cite{Newton1999}");
+
+        TexBibEntriesResolverResult crossingResult = new TexBibEntriesResolver(database).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult = new TexBibEntriesResolverResult(expectedParserResult);
+
+        expectedCrossingResult.insertEntry(database, DARWIN);
+        expectedCrossingResult.insertEntry(database, EINSTEIN);
+        expectedCrossingResult.insertEntry(database, NEWTON);
+
+        assertEquals(expectedCrossingResult, crossingResult);
+
+        TexBibEntriesResolverResult crossingResult2 = new TexBibEntriesResolver(database2).resolveKeys(parserResult);
+        TexBibEntriesResolverResult expectedCrossingResult2 = new TexBibEntriesResolverResult(expectedParserResult);
+
+        expectedCrossingResult2.insertEntry(database2, EINSTEIN);
+        expectedCrossingResult2.addUnresolvedKey(DARWIN);
+        expectedCrossingResult2.addUnresolvedKey(NEWTON);
+
+        assertEquals(expectedCrossingResult2, crossingResult2);
+    }
+}
diff --git a/src/test/resources/org/jabref/logic/texparser/crossref.tex b/src/test/resources/org/jabref/logic/texparser/crossref.tex
new file mode 100644
index 00000000000..4a2809c0d16
--- /dev/null
+++ b/src/test/resources/org/jabref/logic/texparser/crossref.tex
@@ -0,0 +1,11 @@
+\documentclass{article}
+
+\begin{document}
+This is some content trying to cite a bib file: \cite{Einstein1920a}
+This is some content trying to cite a bib file: \cite{Einstein1920b}
+This is some content trying to cite a bib file: \cite{Einstein1920c}
+This is some content trying to cite a bib file: \cite{UnresolvedKey}
+
+\bibliographystyle{plain}
+\bibliography{origin}
+\end{document}
diff --git a/src/test/resources/org/jabref/logic/texparser/nested.tex b/src/test/resources/org/jabref/logic/texparser/nested.tex
new file mode 100644
index 00000000000..e43fa1eaf14
--- /dev/null
+++ b/src/test/resources/org/jabref/logic/texparser/nested.tex
@@ -0,0 +1,9 @@
+\documentclass{article}
+\begin{document}
+
+This is some content trying to cite a bib file.
+\include{nested2}
+
+\bibliographystyle{plain}
+\bibliography{origin}
+\end{document}
diff --git a/src/test/resources/org/jabref/logic/texparser/nested2.tex b/src/test/resources/org/jabref/logic/texparser/nested2.tex
new file mode 100644
index 00000000000..84e07c2ca67
--- /dev/null
+++ b/src/test/resources/org/jabref/logic/texparser/nested2.tex
@@ -0,0 +1,9 @@
+\documentclass{article}
+\begin{document}
+
+This is some content trying to cite a bib file.
+\input{paper}
+
+\bibliographystyle{plain}
+\bibliography{origin}
+\end{document}
diff --git a/src/test/resources/org/jabref/logic/texparser/paper.tex b/src/test/resources/org/jabref/logic/texparser/paper.tex
new file mode 100644
index 00000000000..5a8afd4ab0e
--- /dev/null
+++ b/src/test/resources/org/jabref/logic/texparser/paper.tex
@@ -0,0 +1,13 @@
+\documentclass{article}
+\begin{document}
+
+\cite{Einstein1920}
+\cite{Darwin1888}.
+Einstein said \cite{Einstein1920} that lorem impsum, consectetur adipiscing elit.
+Nunc ultricies leo nec libero rhoncus, eu vehicula enim efficitur. \cite{Darwin1888}
+
+% Comment with \cite{Darwin1888}
+
+\bibliographystyle{plain}
+\bibliography{origin}
+\end{document}
diff --git a/src/test/resources/org/jabref/logic/texparser/paper2.tex b/src/test/resources/org/jabref/logic/texparser/paper2.tex
new file mode 100644
index 00000000000..6e3f81fee3c
--- /dev/null
+++ b/src/test/resources/org/jabref/logic/texparser/paper2.tex
@@ -0,0 +1,10 @@
+\documentclass{article}
+\begin{document}
+
+This is some content trying to cite a bib file: \cite{Darwin1888}
+This is some content trying to cite a bib file: \cite{Einstein1920}
+This is some content trying to cite a bib file: \cite{Newton1999}
+
+\bibliographystyle{plain}
+\bibliography{origin}
+\end{document}
diff --git a/src/test/resources/org/jabref/logic/texparser/unknown_key.tex b/src/test/resources/org/jabref/logic/texparser/unknown_key.tex
new file mode 100644
index 00000000000..3543179b4c4
--- /dev/null
+++ b/src/test/resources/org/jabref/logic/texparser/unknown_key.tex
@@ -0,0 +1,10 @@
+\documentclass{article}
+\begin{document}
+
+This is some content trying to cite a bib file: \cite{Darwin1888}
+This is some content trying to cite a bib file: \cite{Einstein1920}
+This is some content trying to cite a bib file: \cite{UnknownKey}
+
+\bibliographystyle{plain}
+\bibliography{origin}
+\end{document}