diff --git a/.github/workflows/gradle-wrapper-validation.yml b/.github/workflows/gradle-wrapper-validation.yml
new file mode 100644
index 00000000000..6cb3bb97290
--- /dev/null
+++ b/.github/workflows/gradle-wrapper-validation.yml
@@ -0,0 +1,14 @@
+# This is https://github.com/marketplace/actions/gradle-wrapper-validation
+# It ensures that the jar file is from gradle and not by a strange third party.
+
+name: "Validate Gradle Wrapper"
+on: [push, pull_request]
+
+jobs:
+  validation:
+    name: "Validation"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: gradle/wrapper-validation-action@v1
+
diff --git a/CHANGELOG.md b/CHANGELOG.md
index ae9e8816e5d..88539afa5ac 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -13,6 +13,7 @@ We refer to [GitHub issues](https://github.com/JabRef/jabref/issues) by using `#
 
 ### Changed
 
+- We reintroduced the possibility to extract references from plain text (using GROBID) [#5614](https://github.com/JabRef/jabref/pull/5614) 
 - We changed the open office panel to show buttons in rows of three instead of going straight down to save space as the button expanded out to take up unnecessary horizontal space. [#5479](https://github.com/JabRef/jabref/issues/5479)
 - We cleaned up the group add/edit dialog. [#5826](https://github.com/JabRef/jabref/pull/5826)
 - We reintroduced the index column. [#5844](https://github.com/JabRef/jabref/pull/5844)
@@ -22,6 +23,7 @@ We refer to [GitHub issues](https://github.com/JabRef/jabref/issues) by using `#
 
 ### Fixed
 
+- We fixed an issue where the command line console was always opened in the background. [#5474](https://github.com/JabRef/jabref/issues/5474)
 - We fixed and issue where pdf files will not open under some KDE linux distributions when using okular. [#5253](https://github.com/JabRef/jabref/issues/5253)
 - We fixed an issue where the Medline fetcher was only working when JabRef was running from source. [#5645](https://github.com/JabRef/jabref/issues/5645)
 - We fixed some visual issues in the dark theme. [#5764](https://github.com/JabRef/jabref/pull/5764) [#5753](https://github.com/JabRef/jabref/issues/5753)
diff --git a/build.gradle b/build.gradle
index c91a97a42c7..e942fe2262b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -23,7 +23,7 @@ plugins {
     id 'com.github.ben-manes.versions' version '0.27.0'
     id 'org.javamodularity.moduleplugin' version '1.5.0'
     id 'org.openjfx.javafxplugin' version '0.0.8'
-    id 'org.beryx.jlink' version '2.17.1'
+    id 'org.beryx.jlink' version '2.17.2'
 
     // nicer test outputs during running and completion
     id 'com.adarshr.test-logger' version '2.0.0'
@@ -255,7 +255,7 @@ dependencyUpdates.resolutionStrategy = {
         }
         rules.withModule("de.jensd:fontawesomefx-materialdesignfont") { ComponentSelection selection ->
             if (selection.candidate.version ==~ /2.0.26-9.1.2/
-                || selection.candidate.version ==~ /2.0.26-9.1.1/ 
+                || selection.candidate.version ==~ /2.0.26-9.1.1/
                 || selection.candidate.version ==~ /2.0.26-9.1.0/) {
                 selection.reject('1.7.22-11 is actually newer (strange version system)')
             }
@@ -590,7 +590,7 @@ jlink {
         requires 'java.rmi'
         requires 'java.xml'
         requires 'com.sun.xml.txw2'
-        requires 'com.google.gson';
+        requires 'com.google.gson'
         requires 'java.desktop'
         requires 'java.security.jgss'
         requires 'jdk.jsobject'
@@ -628,7 +628,6 @@ jlink {
             // This requires WiX to be installed: https://github.com/wixtoolset/wix3/releases
             installerType = "msi"
             imageOptions = [
-                    '--win-console',
                     '--icon', "${projectDir}/src/main/resources/icons/jabref.ico",
             ]
             installerOptions = [
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index cc4fdc293d0..f3d88b1c2fa 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 1b16c34a71c..b7c8c5dbf58 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.1.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-6.2-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/src/main/java/org/jabref/gui/JabRefFrame.java b/src/main/java/org/jabref/gui/JabRefFrame.java
index f30ff15512c..5a4c0476b97 100644
--- a/src/main/java/org/jabref/gui/JabRefFrame.java
+++ b/src/main/java/org/jabref/gui/JabRefFrame.java
@@ -486,6 +486,7 @@ private Node createToolbar() {
         HBox rightSide = new HBox(
                 factory.createIconButton(StandardActions.NEW_ARTICLE, new NewEntryAction(this, StandardEntryType.Article, dialogService, Globals.prefs, stateManager)),
                 factory.createIconButton(StandardActions.NEW_ENTRY, new NewEntryAction(this, dialogService, Globals.prefs, stateManager)),
+                factory.createIconButton(StandardActions.NEW_ENTRY_FROM_PLAIN_TEXT, new ExtractBibtexAction(stateManager)),
                 factory.createIconButton(StandardActions.DELETE_ENTRY, new OldDatabaseCommandWrapper(Actions.DELETE, this, stateManager)),
                 new Separator(Orientation.VERTICAL),
                 factory.createIconButton(StandardActions.UNDO, new OldDatabaseCommandWrapper(Actions.UNDO, this, stateManager)),
@@ -734,6 +735,7 @@ private MenuBar createMenu() {
         //@formatter:off
         library.getItems().addAll(
                 factory.createMenuItem(StandardActions.NEW_ENTRY, new NewEntryAction(this, dialogService, Globals.prefs, stateManager)),
+                factory.createMenuItem(StandardActions.NEW_ENTRY_FROM_PLAIN_TEXT, new ExtractBibtexAction(stateManager)),
                 factory.createMenuItem(StandardActions.DELETE_ENTRY, new OldDatabaseCommandWrapper(Actions.DELETE, this, stateManager)),
 
                 new SeparatorMenuItem(),
@@ -773,7 +775,6 @@ private MenuBar createMenu() {
                 factory.createMenuItem(StandardActions.FIND_UNLINKED_FILES, new FindUnlinkedFilesAction(this, stateManager)),
                 factory.createMenuItem(StandardActions.WRITE_XMP, new WriteXMPAction(stateManager, dialogService)),
                 factory.createMenuItem(StandardActions.COPY_LINKED_FILES, new CopyFilesAction(stateManager, this.getDialogService())),
-                factory.createMenuItem(StandardActions.EXTRACT_BIBTEX, new ExtractBibtexAction(stateManager)),
 
                 new SeparatorMenuItem(),
 
diff --git a/src/main/java/org/jabref/gui/actions/StandardActions.java b/src/main/java/org/jabref/gui/actions/StandardActions.java
index 87f48f1b4a5..245c20e30d5 100644
--- a/src/main/java/org/jabref/gui/actions/StandardActions.java
+++ b/src/main/java/org/jabref/gui/actions/StandardActions.java
@@ -120,7 +120,7 @@ public enum StandardActions implements Action {
 
     NEW_ENTRY(Localization.lang("New entry"), IconTheme.JabRefIcons.ADD_ENTRY, KeyBinding.NEW_ENTRY),
     NEW_ARTICLE(Localization.lang("New article"), IconTheme.JabRefIcons.ADD_ARTICLE),
-    NEW_ENTRY_FROM_PLAINTEX(Localization.lang("New entry from plain text"), KeyBinding.NEW_FROM_PLAIN_TEXT),
+    NEW_ENTRY_FROM_PLAIN_TEXT(Localization.lang("New entry from plain text"), IconTheme.JabRefIcons.NEW_ENTRY_FROM_PLAIN_TEXT, KeyBinding.NEW_ENTRY_FROM_PLAIN_TEXT),
     LIBRARY_PROPERTIES(Localization.lang("Library properties")),
     EDIT_PREAMBLE(Localization.lang("Edit preamble")),
     EDIT_STRINGS(Localization.lang("Edit string constants"), IconTheme.JabRefIcons.EDIT_STRINGS, KeyBinding.EDIT_STRINGS),
@@ -138,7 +138,6 @@ public enum StandardActions implements Action {
     DOWNLOAD_FULL_TEXT(Localization.lang("Search full text documents online"), IconTheme.JabRefIcons.FILE_SEARCH, KeyBinding.DOWNLOAD_FULL_TEXT),
     CLEANUP_ENTRIES(Localization.lang("Cleanup entries"), IconTheme.JabRefIcons.CLEANUP_ENTRIES, KeyBinding.CLEANUP),
     SET_FILE_LINKS(Localization.lang("Automatically set file links"), KeyBinding.AUTOMATICALLY_LINK_FILES),
-    EXTRACT_BIBTEX(Localization.lang("Extract BibTeX from plain text")),
 
     HELP(Localization.lang("Online help"), IconTheme.JabRefIcons.HELP, KeyBinding.HELP),
     HELP_KEY_PATTERNS(Localization.lang("Help on key patterns"), IconTheme.JabRefIcons.HELP, KeyBinding.HELP),
diff --git a/src/main/java/org/jabref/gui/bibtexextractor/BibtexExtractorViewModel.java b/src/main/java/org/jabref/gui/bibtexextractor/BibtexExtractorViewModel.java
index 8eb694bd692..c68ae79c3a8 100644
--- a/src/main/java/org/jabref/gui/bibtexextractor/BibtexExtractorViewModel.java
+++ b/src/main/java/org/jabref/gui/bibtexextractor/BibtexExtractorViewModel.java
@@ -3,40 +3,60 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import javax.swing.undo.UndoManager;
+
 import javafx.beans.property.SimpleStringProperty;
 import javafx.beans.property.StringProperty;
 
 import org.jabref.Globals;
+import org.jabref.gui.DialogService;
+import org.jabref.gui.StateManager;
+import org.jabref.gui.externalfiles.ImportHandler;
+import org.jabref.gui.externalfiletype.ExternalFileTypes;
+import org.jabref.gui.util.BackgroundTask;
+import org.jabref.gui.util.TaskExecutor;
+import org.jabref.logic.importer.fetcher.GrobidCitationFetcher;
+import org.jabref.logic.l10n.Localization;
 import org.jabref.model.database.BibDatabaseContext;
 import org.jabref.model.entry.BibEntry;
-import org.jabref.model.entry.types.EntryType;
-import org.jabref.model.entry.types.StandardEntryType;
+import org.jabref.model.util.FileUpdateMonitor;
+import org.jabref.preferences.JabRefPreferences;
 
 public class BibtexExtractorViewModel {
 
     private final StringProperty inputTextProperty = new SimpleStringProperty("");
-    private final BibDatabaseContext bibdatabaseContext;
-
-    public BibtexExtractorViewModel(BibDatabaseContext bibdatabaseContext) {
-        this.bibdatabaseContext = bibdatabaseContext;
+    private DialogService dialogService;
+    private GrobidCitationFetcher currentCitationfetcher;
+    private TaskExecutor taskExecutor;
+    private ImportHandler importHandler;
+
+    public BibtexExtractorViewModel(BibDatabaseContext bibdatabaseContext, DialogService dialogService,
+                                    JabRefPreferences jabRefPreferences, FileUpdateMonitor fileUpdateMonitor, TaskExecutor taskExecutor, UndoManager undoManager, StateManager stateManager) {
+        this.dialogService = dialogService;
+        currentCitationfetcher = new GrobidCitationFetcher(jabRefPreferences.getImportFormatPreferences());
+        this.taskExecutor = taskExecutor;
+        this.importHandler = new ImportHandler(dialogService, bibdatabaseContext, ExternalFileTypes.getInstance(), jabRefPreferences.getFilePreferences(), jabRefPreferences.getImportFormatPreferences(), jabRefPreferences.getUpdateFieldPreferences(), fileUpdateMonitor, undoManager, stateManager);
     }
 
     public StringProperty inputTextProperty() {
         return this.inputTextProperty;
     }
 
-    public void startExtraction() {
-
-        BibtexExtractor extractor = new BibtexExtractor();
-        BibEntry entity = extractor.extract(inputTextProperty.getValue());
-        this.bibdatabaseContext.getDatabase().insertEntry(entity);
-        trackNewEntry(StandardEntryType.Article);
+    public void startParsing() {
+        BackgroundTask.wrap(() -> currentCitationfetcher.performSearch(inputTextProperty.getValue()))
+                .onRunning(() -> dialogService.notify(Localization.lang("Your text is being parsed...")))
+                .onSuccess(parsedEntries -> {
+                    dialogService.notify(Localization.lang("%0 entries were parsed from your query.", String.valueOf(parsedEntries.size())));
+                    importHandler.importEntries(parsedEntries);
+                    for (BibEntry bibEntry : parsedEntries) {
+                        trackNewEntry(bibEntry);
+                    }
+                }).executeWith(taskExecutor);
     }
 
-    private void trackNewEntry(EntryType type) {
+    private void trackNewEntry(BibEntry bibEntry) {
         Map<String, String> properties = new HashMap<>();
-        properties.put("EntryType", type.getName());
-
-        Globals.getTelemetryClient().ifPresent(client -> client.trackEvent("NewEntry", properties, new HashMap<>()));
+        properties.put("EntryType", bibEntry.typeProperty().getValue().getName());
+        Globals.getTelemetryClient().ifPresent(client -> client.trackEvent("ParseWithGrobid", properties, new HashMap<>()));
     }
 }
diff --git a/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.fxml b/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.fxml
index 053024c2a6a..d2182cbaf9c 100644
--- a/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.fxml
+++ b/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.fxml
@@ -4,11 +4,17 @@
 <?import javafx.scene.control.DialogPane?>
 <?import javafx.scene.control.TextArea?>
 
+<?import javafx.scene.layout.VBox?>
+
 <DialogPane prefHeight="430.0" prefWidth="586.0" xmlns="http://javafx.com/javafx/8.0.171"
             xmlns:fx="http://javafx.com/fxml/1" fx:controller="org.jabref.gui.bibtexextractor.ExtractBibtexDialog">
     <content>
-        <TextArea fx:id="input" minHeight="-Infinity" prefHeight="350.0" prefWidth="586.0"/>
+        <VBox fx:id="contentVbox" minHeight="-Infinity" prefHeight="200.0" prefWidth="100.0">
+        <children>
+            <TextArea fx:id="input" minHeight="-Infinity" prefHeight="350.0" prefWidth="586.0" wrapText="true"/>
+        </children>
+        </VBox>
     </content>
-    <ButtonType fx:id="extractButtonType" buttonData="OK_DONE" text="%Extract"/>
+    <ButtonType fx:id="parseButtonType" buttonData="OK_DONE" text = "%Add to current library"/>
     <ButtonType fx:constant="CANCEL"/>
 </DialogPane>
diff --git a/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.java b/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.java
index f4b7a1af81b..2354ef88cc5 100644
--- a/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.java
+++ b/src/main/java/org/jabref/gui/bibtexextractor/ExtractBibtexDialog.java
@@ -1,6 +1,7 @@
 package org.jabref.gui.bibtexextractor;
 
 import javax.inject.Inject;
+import javax.swing.undo.UndoManager;
 
 import javafx.fxml.FXML;
 import javafx.scene.control.Button;
@@ -8,10 +9,14 @@
 import javafx.scene.control.TextArea;
 import javafx.scene.control.Tooltip;
 
+import org.jabref.gui.DialogService;
 import org.jabref.gui.StateManager;
 import org.jabref.gui.util.BaseDialog;
+import org.jabref.gui.util.TaskExecutor;
 import org.jabref.logic.l10n.Localization;
 import org.jabref.model.database.BibDatabaseContext;
+import org.jabref.model.util.FileUpdateMonitor;
+import org.jabref.preferences.JabRefPreferences;
 
 import com.airhacks.afterburner.views.ViewLoader;
 
@@ -20,31 +25,34 @@
  */
 public class ExtractBibtexDialog extends BaseDialog<Void> {
 
-    private final Button buttonExtract;
+    private final Button buttonParse;
     @FXML private TextArea input;
-    @FXML private ButtonType extractButtonType;
+    @FXML private ButtonType parseButtonType;
     private BibtexExtractorViewModel viewModel;
-
     @Inject private StateManager stateManager;
+    @Inject private DialogService dialogService;
+    @Inject private FileUpdateMonitor fileUpdateMonitor;
+    @Inject private TaskExecutor taskExecutor;
+    @Inject private UndoManager undoManager;
 
     public ExtractBibtexDialog() {
-
         ViewLoader.view(this)
                   .load()
                   .setAsDialogPane(this);
-
-        this.setTitle(Localization.lang("Input text to parse"));
-        buttonExtract = (Button) getDialogPane().lookupButton(extractButtonType);
-        buttonExtract.setTooltip(new Tooltip((Localization.lang("Starts the extraction of the BibTeX entry"))));
-        buttonExtract.setOnAction(e -> viewModel.startExtraction());
-        buttonExtract.disableProperty().bind(viewModel.inputTextProperty().isEmpty());
+        this.setTitle(Localization.lang("Plain References Parser"));
+        input.setPromptText(Localization.lang("Please enter the plain references to extract from separated by double empty lines."));
+        input.selectAll();
+
+        buttonParse = (Button) getDialogPane().lookupButton(parseButtonType);
+        buttonParse.setTooltip(new Tooltip((Localization.lang("Starts the extraction and adds the resulting entries to the currently opened database"))));
+        buttonParse.setOnAction(event -> viewModel.startParsing());
+        buttonParse.disableProperty().bind(viewModel.inputTextProperty().isEmpty());
     }
 
     @FXML
     private void initialize() {
         BibDatabaseContext database = stateManager.getActiveDatabase().orElseThrow(() -> new NullPointerException("Database null"));
-        this.viewModel = new BibtexExtractorViewModel(database);
-
+        this.viewModel = new BibtexExtractorViewModel(database, dialogService, JabRefPreferences.getInstance(), fileUpdateMonitor, taskExecutor,undoManager,stateManager);
         input.textProperty().bindBidirectional(viewModel.inputTextProperty());
     }
 }
diff --git a/src/main/java/org/jabref/gui/desktop/os/Linux.java b/src/main/java/org/jabref/gui/desktop/os/Linux.java
index a39c6e335d2..579b4986774 100644
--- a/src/main/java/org/jabref/gui/desktop/os/Linux.java
+++ b/src/main/java/org/jabref/gui/desktop/os/Linux.java
@@ -11,8 +11,10 @@
 import java.util.Optional;
 import java.util.StringJoiner;
 
+import org.jabref.JabRefExecutorService;
 import org.jabref.gui.externalfiletype.ExternalFileType;
 import org.jabref.gui.externalfiletype.ExternalFileTypes;
+import org.jabref.gui.util.StreamGobbler;
 import org.jabref.preferences.JabRefPreferences;
 
 import org.slf4j.Logger;
@@ -22,6 +24,7 @@
 import static org.jabref.preferences.JabRefPreferences.USE_PDF_READER;
 
 public class Linux implements NativeDesktop {
+
     private static final Logger LOGGER = LoggerFactory.getLogger(Linux.class);
 
     @Override
@@ -34,14 +37,13 @@ public void openFile(String filePath, String fileType) throws IOException {
         } else {
             viewer = "xdg-open";
         }
-        String[] cmdArray = { viewer, filePath };
-        Process p = Runtime.getRuntime().exec(cmdArray);
-        // When the stream is full at some point, then blocks the execution of the program
-        // See https://stackoverflow.com/questions/10981969/why-is-going-through-geterrorstream-necessary-to-run-a-process.
-        BufferedReader in = new BufferedReader(new InputStreamReader(p.getErrorStream()));
-        String line;
-        line = in.readLine();
-        LOGGER.debug("Received output: " + line);
+        ProcessBuilder processBuilder = new ProcessBuilder(viewer, filePath);
+        Process process = processBuilder.start();
+        StreamGobbler streamGobblerInput = new StreamGobbler(process.getInputStream(), LOGGER::debug);
+        StreamGobbler streamGobblerError = new StreamGobbler(process.getErrorStream(), LOGGER::debug);
+
+        JabRefExecutorService.INSTANCE.execute(streamGobblerInput);
+        JabRefExecutorService.INSTANCE.execute(streamGobblerError);
     }
 
     @Override
@@ -53,17 +55,18 @@ public void openFileWithApplication(String filePath, String application) throws
         } else {
             openWith = new String[] {"xdg-open"};
         }
-
         String[] cmdArray = new String[openWith.length + 1];
         System.arraycopy(openWith, 0, cmdArray, 0, openWith.length);
         cmdArray[cmdArray.length - 1] = filePath;
-        Process p = Runtime.getRuntime().exec(cmdArray);
-        // When the stream is full at some point, then blocks the execution of the program
-        // See https://stackoverflow.com/questions/10981969/why-is-going-through-geterrorstream-necessary-to-run-a-process.
-        BufferedReader in = new BufferedReader(new InputStreamReader(p.getErrorStream()));
-        String line;
-        line = in.readLine();
-        LOGGER.debug("Received output: " + line);
+
+        ProcessBuilder processBuilder = new ProcessBuilder(cmdArray);
+        Process process = processBuilder.start();
+
+        StreamGobbler streamGobblerInput = new StreamGobbler(process.getInputStream(), LOGGER::debug);
+        StreamGobbler streamGobblerError = new StreamGobbler(process.getErrorStream(), LOGGER::debug);
+
+        JabRefExecutorService.INSTANCE.execute(streamGobblerInput);
+        JabRefExecutorService.INSTANCE.execute(streamGobblerError);
     }
 
     @Override
@@ -118,7 +121,7 @@ public void openPdfWithParameters(String filePath, List<String> parameters) thro
 
             openFileWithApplication(filePath, sj.toString());
         } else {
-            openFile( filePath, "PDF");
+            openFile(filePath, "PDF");
         }
     }
 
diff --git a/src/main/java/org/jabref/gui/icon/IconTheme.java b/src/main/java/org/jabref/gui/icon/IconTheme.java
index 94e3ec56054..2df5017c21f 100644
--- a/src/main/java/org/jabref/gui/icon/IconTheme.java
+++ b/src/main/java/org/jabref/gui/icon/IconTheme.java
@@ -298,7 +298,8 @@ public enum JabRefIcons implements JabRefIcon {
         OPEN_ABBREVIATION_LIST(MaterialDesignIcon.FOLDER_OUTLINE),
         REMOVE_ABBREVIATION_LIST(MaterialDesignIcon.FOLDER_REMOVE),
         ADD_ABBREVIATION(MaterialDesignIcon.PLAYLIST_PLUS),
-        REMOVE_ABBREVIATION(MaterialDesignIcon.PLAYLIST_MINUS);
+        REMOVE_ABBREVIATION(MaterialDesignIcon.PLAYLIST_MINUS),
+        NEW_ENTRY_FROM_PLAIN_TEXT(MaterialDesignIcon.PLUS_BOX);
 
         private final JabRefIcon icon;
 
diff --git a/src/main/java/org/jabref/gui/keyboard/KeyBinding.java b/src/main/java/org/jabref/gui/keyboard/KeyBinding.java
index 17d5e6aef88..7c4f66a193d 100644
--- a/src/main/java/org/jabref/gui/keyboard/KeyBinding.java
+++ b/src/main/java/org/jabref/gui/keyboard/KeyBinding.java
@@ -48,7 +48,7 @@ public enum KeyBinding {
     NEW_ARTICLE("New article", Localization.lang("New article"), "ctrl+shift+A", KeyBindingCategory.BIBTEX),
     NEW_BOOK("New book", Localization.lang("New book"), "ctrl+shift+B", KeyBindingCategory.BIBTEX),
     NEW_ENTRY("New entry", Localization.lang("New entry"), "ctrl+N", KeyBindingCategory.BIBTEX),
-    NEW_FROM_PLAIN_TEXT("New from plain text", Localization.lang("New from plain text"), "ctrl+shift+N", KeyBindingCategory.BIBTEX),
+    NEW_ENTRY_FROM_PLAIN_TEXT("New entry from plain text", Localization.lang("New entry from plain text"), "ctrl+shift+N", KeyBindingCategory.BIBTEX),
     NEW_INBOOK("New inbook", Localization.lang("New inbook"), "ctrl+shift+I", KeyBindingCategory.BIBTEX),
     NEW_MASTERSTHESIS("New mastersthesis", Localization.lang("New mastersthesis"), "ctrl+shift+M", KeyBindingCategory.BIBTEX),
     NEW_PHDTHESIS("New phdthesis", Localization.lang("New phdthesis"), "ctrl+shift+T", KeyBindingCategory.BIBTEX),
diff --git a/src/main/java/org/jabref/gui/util/StreamGobbler.java b/src/main/java/org/jabref/gui/util/StreamGobbler.java
new file mode 100644
index 00000000000..b2131968f87
--- /dev/null
+++ b/src/main/java/org/jabref/gui/util/StreamGobbler.java
@@ -0,0 +1,32 @@
+package org.jabref.gui.util;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.function.Consumer;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class StreamGobbler implements Runnable {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(StreamGobbler.class);
+
+    private InputStream inputStream;
+    private Consumer<String> consumer;
+
+    public StreamGobbler(InputStream inputStream, Consumer<String> consumer) {
+        this.inputStream = inputStream;
+        this.consumer = consumer;
+    }
+
+    @Override
+    public void run() {
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
+            reader.lines().forEach(consumer);
+        } catch (IOException e) {
+            LOGGER.error("Error when reading process stream from external application", e);
+        }
+    }
+}
diff --git a/src/main/java/org/jabref/logic/importer/WebFetchers.java b/src/main/java/org/jabref/logic/importer/WebFetchers.java
index 45f035914ca..f901ea0588a 100644
--- a/src/main/java/org/jabref/logic/importer/WebFetchers.java
+++ b/src/main/java/org/jabref/logic/importer/WebFetchers.java
@@ -18,6 +18,7 @@
 import org.jabref.logic.importer.fetcher.DoiFetcher;
 import org.jabref.logic.importer.fetcher.DoiResolution;
 import org.jabref.logic.importer.fetcher.GoogleScholar;
+import org.jabref.logic.importer.fetcher.GrobidCitationFetcher;
 import org.jabref.logic.importer.fetcher.GvkFetcher;
 import org.jabref.logic.importer.fetcher.IEEE;
 import org.jabref.logic.importer.fetcher.INSPIREFetcher;
@@ -98,6 +99,7 @@ public static SortedSet<SearchBasedFetcher> getSearchBasedFetchers(ImportFormatP
         set.add(new CiteSeer());
         set.add(new DOAJFetcher(importFormatPreferences));
         set.add(new IEEE(importFormatPreferences));
+        set.add(new GrobidCitationFetcher(importFormatPreferences));
         return set;
     }
 
diff --git a/src/main/java/org/jabref/logic/importer/fetcher/GrobidCitationFetcher.java b/src/main/java/org/jabref/logic/importer/fetcher/GrobidCitationFetcher.java
new file mode 100644
index 00000000000..5f1fbe66aab
--- /dev/null
+++ b/src/main/java/org/jabref/logic/importer/fetcher/GrobidCitationFetcher.java
@@ -0,0 +1,77 @@
+package org.jabref.logic.importer.fetcher;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.logic.importer.ParseException;
+import org.jabref.logic.importer.SearchBasedFetcher;
+import org.jabref.logic.importer.fileformat.BibtexParser;
+import org.jabref.logic.importer.util.GrobidService;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.util.DummyFileUpdateMonitor;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class GrobidCitationFetcher implements SearchBasedFetcher {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(GrobidCitationFetcher.class);
+    private static final String GROBID_URL = "http://grobid.cm.in.tum.de:8070";
+    private ImportFormatPreferences importFormatPreferences;
+    private GrobidService grobidService;
+
+    public GrobidCitationFetcher(ImportFormatPreferences importFormatPreferences) {
+        this.importFormatPreferences = importFormatPreferences;
+        this.grobidService = new GrobidService(GROBID_URL);
+    }
+
+    /**
+     * Passes request to grobid server, using consolidateCitations option to improve result.
+     * Takes a while, since the server has to look up the entry.
+     * @return A BibTeX-String if extraction is successful and an empty String otherwise.
+     */
+    private String parseUsingGrobid(String plainText) {
+        try {
+            return grobidService.processCitation(plainText, GrobidService.ConsolidateCitations.WITH_METADATA);
+        } catch (IOException e) {
+            LOGGER.debug("Could not process citation", e);
+            return "";
+        }
+    }
+
+    private Optional<BibEntry> parseBibToBibEntry(String bibtexString) {
+        try {
+            return BibtexParser.singleFromString(bibtexString,
+                    importFormatPreferences, new DummyFileUpdateMonitor());
+        } catch (ParseException e) {
+            return Optional.empty();
+        }
+    }
+
+    @Override
+    public List<BibEntry> performSearch(String query) {
+        List<String> plainReferences = Arrays.stream( query.split( "\\r\\r+|\\n\\n+|\\r\\n(\\r\\n)+" ) )
+              .map(String::trim)
+              .filter(str -> !str.isBlank())
+              .collect(Collectors.toCollection(ArrayList::new));
+        if (plainReferences.isEmpty()) {
+            return Collections.emptyList();
+        } else {
+            return plainReferences.stream()
+                  .map(reference -> parseBibToBibEntry(parseUsingGrobid(reference)))
+                  .flatMap(Optional::stream)
+                  .collect(Collectors.toList());
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "GROBID";
+    }
+}
diff --git a/src/main/java/org/jabref/logic/importer/util/GrobidService.java b/src/main/java/org/jabref/logic/importer/util/GrobidService.java
new file mode 100644
index 00000000000..146a31990ec
--- /dev/null
+++ b/src/main/java/org/jabref/logic/importer/util/GrobidService.java
@@ -0,0 +1,57 @@
+package org.jabref.logic.importer.util;
+
+import java.io.IOException;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+
+import org.jabref.logic.net.URLDownload;
+
+/**
+ * Implements an API to a GROBID server, as described at
+ * https://grobid.readthedocs.io/en/latest/Grobid-service/#grobid-web-services
+ * <p>
+ * Note: Currently a custom GROBID server is used...
+ * https://github.com/NikodemKch/grobid
+ * <p>
+ * The methods are structured to match the GROBID server api.
+ * Each method corresponds to a GROBID service request. Only the ones already used are already implemented.
+ */
+public class GrobidService {
+
+    public enum ConsolidateCitations {
+        NO(0), WITH_METADATA(1), WITH_DOI_ONLY(2);
+        private int code;
+
+        ConsolidateCitations(int code) {
+            this.code = code;
+        }
+
+        public int getCode() {
+            return this.code;
+        }
+    }
+
+    String grobidServerURL;
+
+    public GrobidService(String grobidServerURL) {
+        this.grobidServerURL = grobidServerURL;
+    }
+
+    /**
+     * @return A BibTeX-String if extraction is successful and an IOException otherwise.
+     */
+    public String processCitation(String rawCitation, ConsolidateCitations consolidateCitations) throws IOException {
+        rawCitation = URLEncoder.encode(rawCitation, StandardCharsets.UTF_8);
+        URLDownload urlDownload = new URLDownload(grobidServerURL
+                + "/api/processCitation");
+        //urlDownload.addHeader("Accept", "application/x-bibtex"); //TODO: Uncomment as soon as the default GROBID server is used.
+        urlDownload.setPostData("citations=" + rawCitation + "&consolidateCitations=" + consolidateCitations);
+        String httpResponse = urlDownload.asString();
+
+        if (httpResponse == null || httpResponse.equals("@misc{-1,\n\n}\n")) { //This filters empty BibTeX entries
+            throw new IOException("The GROBID server response does not contain anything.");
+        }
+
+        return httpResponse;
+    }
+}
diff --git a/src/main/java/org/jabref/logic/shared/DBMSProcessor.java b/src/main/java/org/jabref/logic/shared/DBMSProcessor.java
index 0e6d9550e5c..9ef40561391 100644
--- a/src/main/java/org/jabref/logic/shared/DBMSProcessor.java
+++ b/src/main/java/org/jabref/logic/shared/DBMSProcessor.java
@@ -16,12 +16,14 @@
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
+import java.util.stream.Collectors;
 
 import org.jabref.logic.shared.exception.OfflineLockException;
 import org.jabref.model.database.shared.DBMSType;
 import org.jabref.model.database.shared.DatabaseConnection;
 import org.jabref.model.database.shared.DatabaseConnectionProperties;
 import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.SharedBibEntryData;
 import org.jabref.model.entry.event.EntriesEventSource;
 import org.jabref.model.entry.field.Field;
 import org.jabref.model.entry.field.FieldFactory;
@@ -131,40 +133,61 @@ public void setupSharedDatabase() throws SQLException {
     abstract String escape(String expression);
 
     /**
-     * Inserts the given bibEntry into shared database.
+     * For use in test only. Inserts the BibEntry into the shared database.
      *
-     * @param bibEntry {@link BibEntry} to be inserted
+     * @param bibEntry {@link BibEntry} to be inserted.
+     * */
+     public void insertEntry(BibEntry bibEntry) {
+         insertEntries(Collections.singletonList(bibEntry));
+     }
+
+    /**
+     * Inserts the List of BibEntry into the shared database.
+     *
+     * @param bibEntries List of {@link BibEntry} to be inserted
      */
-    public void insertEntry(BibEntry bibEntry) {
-        if (!checkForBibEntryExistence(bibEntry)) {
-            insertIntoEntryTable(bibEntry);
-            insertIntoFieldTable(bibEntry);
+    public void insertEntries(List<BibEntry> bibEntries) {
+        List<BibEntry> notYetExistingEntries = getNotYetExistingEntries(bibEntries);
+        if (notYetExistingEntries.isEmpty()) {
+            return;
         }
+        insertIntoEntryTable(notYetExistingEntries);
+        insertIntoFieldTable(notYetExistingEntries);
     }
 
     /**
-     * Inserts the given bibEntry into ENTRY table.
+     * Inserts the given List of BibEntry into the ENTRY table.
      *
-     * @param bibEntry {@link BibEntry} to be inserted
+     * @param bibEntries List of {@link BibEntry} to be inserted
      */
-    protected void insertIntoEntryTable(BibEntry bibEntry) {
-        // This is the only method to get generated keys which is accepted by MySQL, PostgreSQL and Oracle.
-        String insertIntoEntryQuery =
-                "INSERT INTO " +
-                        escape("ENTRY") +
-                        "(" +
-                        escape("TYPE") +
-                        ") VALUES(?)";
-
-        try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertIntoEntryQuery,
-                new String[]{"SHARED_ID"})) {
+    protected void insertIntoEntryTable(List<BibEntry> bibEntries) {
+        StringBuilder insertIntoEntryQuery = new StringBuilder()
+                .append("INSERT INTO ")
+                .append(escape("ENTRY"))
+                .append("(")
+                .append(escape("TYPE"))
+                .append(") VALUES(?)");
+        // Number of commas is bibEntries.size() - 1
+        for (int i = 0; i < bibEntries.size() - 1; i++) {
+            insertIntoEntryQuery.append(", (?)");
+        }
 
-            preparedEntryStatement.setString(1, bibEntry.getType().getName());
+        try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertIntoEntryQuery.toString(),
+                new String[]{"SHARED_ID"})) {
+            for (int i = 0; i < bibEntries.size(); i++) {
+                preparedEntryStatement.setString(i + 1, bibEntries.get(i).getType().getName());
+            }
             preparedEntryStatement.executeUpdate();
 
             try (ResultSet generatedKeys = preparedEntryStatement.getGeneratedKeys()) {
+                // The following assumes that we get the generated keys in the order the entries were inserted
+                // This should be the case
+                for (BibEntry bibEntry : bibEntries) {
+                    generatedKeys.next();
+                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1));
+                }
                 if (generatedKeys.next()) {
-                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1)); // set generated ID locally
+                    LOGGER.error("Error: Some shared IDs left unassigned");
                 }
             }
         } catch (SQLException e) {
@@ -173,48 +196,52 @@ protected void insertIntoEntryTable(BibEntry bibEntry) {
     }
 
     /**
-     * Checks whether the given bibEntry already exists on shared database.
+     * Filters a list of BibEntry to and returns those which do not exist in the database
      *
-     * @param bibEntry {@link BibEntry} to be checked
+     * @param bibEntries {@link BibEntry} to be checked
      * @return <code>true</code> if existent, else <code>false</code>
      */
-    private boolean checkForBibEntryExistence(BibEntry bibEntry) {
+    private List<BibEntry> getNotYetExistingEntries(List<BibEntry> bibEntries) {
+
+        List<Integer> remoteIds = new ArrayList<>();
+        List<Integer> localIds = bibEntries.stream()
+                                           .map(BibEntry::getSharedBibEntryData)
+                                           .map(SharedBibEntryData::getSharedID)
+                                           .filter((id) -> id != -1)
+                                           .collect(Collectors.toList());
+        if (localIds.isEmpty()) {
+            return bibEntries;
+        }
         try {
-            // Check if already exists
-            int sharedID = bibEntry.getSharedBibEntryData().getSharedID();
-            if (sharedID != -1) {
-                String selectQuery =
-                        "SELECT * FROM " +
-                                escape("ENTRY") +
-                                " WHERE " +
-                                escape("SHARED_ID") +
-                                " = ?";
-
-                try (PreparedStatement preparedSelectStatement = connection.prepareStatement(selectQuery)) {
-                    preparedSelectStatement.setInt(1, sharedID);
-                    try (ResultSet resultSet = preparedSelectStatement.executeQuery()) {
-                        if (resultSet.next()) {
-                            return true;
-                        }
-                    }
+            StringBuilder selectQuery = new StringBuilder()
+                    .append("SELECT * FROM ")
+                    .append(escape("ENTRY"));
+
+            try (ResultSet resultSet = connection.createStatement().executeQuery(selectQuery.toString())) {
+                while (resultSet.next()) {
+                    int id = resultSet.getInt("SHARED_ID");
+                    remoteIds.add(id);
                 }
             }
         } catch (SQLException e) {
             LOGGER.error("SQL Error: ", e);
         }
-        return false;
-    }
+        return bibEntries.stream().filter((entry) ->
+                !remoteIds.contains(entry.getSharedBibEntryData().getSharedID()))
+                .collect(Collectors.toList());
+        }
 
     /**
-     * Inserts the given bibEntry into FIELD table.
+     * Inserts the given list of BibEntry into FIELD table.
      *
-     * @param bibEntry {@link BibEntry} to be inserted
+     * @param bibEntries {@link BibEntry} to be inserted
      */
-    protected void insertIntoFieldTable(BibEntry bibEntry) {
+    protected void insertIntoFieldTable(List<BibEntry> bibEntries) {
         try {
             // Inserting into FIELD table
             // Coerce to ArrayList in order to use List.get()
-            List<Field> fields = new ArrayList<>(bibEntry.getFields());
+            List<List<Field>> fields = bibEntries.stream().map(bibEntry -> new ArrayList<>(bibEntry.getFields()))
+                                                 .collect(Collectors.toList());
             StringBuilder insertFieldQuery = new StringBuilder()
                     .append("INSERT INTO ")
                     .append(escape("FIELD"))
@@ -225,16 +252,24 @@ protected void insertIntoFieldTable(BibEntry bibEntry) {
                     .append(", ")
                     .append(escape("VALUE"))
                     .append(") VALUES(?, ?, ?)");
+            int numFields = 0;
+            for (List<Field> entryFields : fields) {
+                numFields += entryFields.size();
+            }
             // Number of commas is fields.size() - 1
-            for (int i = 0; i < fields.size() - 1; i++) {
+            for (int i = 0; i < numFields - 1; i++) {
                 insertFieldQuery.append(", (?, ?, ?)");
             }
             try (PreparedStatement preparedFieldStatement = connection.prepareStatement(insertFieldQuery.toString())) {
-                for (int i = 0; i < fields.size(); i++) {
-                    // columnIndex starts with 1
-                    preparedFieldStatement.setInt((3 * i) + 1, bibEntry.getSharedBibEntryData().getSharedID());
-                    preparedFieldStatement.setString((3 * i) + 2, fields.get(i).getName());
-                    preparedFieldStatement.setString((3 * i) + 3, bibEntry.getField(fields.get(i)).get());
+                int fieldsCompleted = 0;
+                for (int entryIndex = 0; entryIndex < fields.size(); entryIndex++) {
+                    for (int entryFieldsIndex = 0; entryFieldsIndex < fields.get(entryIndex).size(); entryFieldsIndex++) {
+                        // columnIndex starts with 1
+                        preparedFieldStatement.setInt((3 * fieldsCompleted) + 1, bibEntries.get(entryIndex).getSharedBibEntryData().getSharedID());
+                        preparedFieldStatement.setString((3 * fieldsCompleted) + 2, fields.get(entryIndex).get(entryFieldsIndex).getName());
+                        preparedFieldStatement.setString((3 * fieldsCompleted) + 3, bibEntries.get(entryIndex).getField(fields.get(entryIndex).get(entryFieldsIndex)).get());
+                        fieldsCompleted += 1;
+                    }
                 }
                 preparedFieldStatement.executeUpdate();
             }
diff --git a/src/main/java/org/jabref/logic/shared/DBMSSynchronizer.java b/src/main/java/org/jabref/logic/shared/DBMSSynchronizer.java
index 72b9fc069f2..6499d78a179 100644
--- a/src/main/java/org/jabref/logic/shared/DBMSSynchronizer.java
+++ b/src/main/java/org/jabref/logic/shared/DBMSSynchronizer.java
@@ -82,12 +82,9 @@ public void listen(EntriesAddedEvent event) {
         if (isEventSourceAccepted(event) && checkCurrentConnection()) {
             synchronizeLocalMetaData();
             synchronizeLocalDatabase(); // Pull changes for the case that there were some
-            List<BibEntry> entries = event.getBibEntries();
-            for (BibEntry entry : entries) {
-                dbmsProcessor.insertEntry(entry);
+            dbmsProcessor.insertEntries(event.getBibEntries());
             }
         }
-    }
 
     /**
      * Listening method. Updates an existing shared {@link BibEntry}.
diff --git a/src/main/java/org/jabref/logic/shared/OracleProcessor.java b/src/main/java/org/jabref/logic/shared/OracleProcessor.java
index 6e4b820bcf4..f4fd183a1d3 100644
--- a/src/main/java/org/jabref/logic/shared/OracleProcessor.java
+++ b/src/main/java/org/jabref/logic/shared/OracleProcessor.java
@@ -1,11 +1,13 @@
 package org.jabref.logic.shared;
 
 import java.sql.PreparedStatement;
+import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Properties;
+import java.util.stream.Collectors;
 
 import org.jabref.logic.shared.listener.OracleNotificationListener;
 import org.jabref.model.database.shared.DatabaseConnection;
@@ -103,14 +105,48 @@ public void startNotificationListener(DBMSSynchronizer dbmsSynchronizer) {
     }
 
     @Override
-    protected void insertIntoFieldTable(BibEntry bibEntry) {
+    protected void insertIntoEntryTable(List<BibEntry> entries) {
+        try {
+            for (BibEntry entry : entries) {
+                String insertIntoEntryQuery =
+                        "INSERT INTO " +
+                                escape("ENTRY") +
+                                "(" +
+                                escape("TYPE") +
+                                ") VALUES(?)";
+
+                try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertIntoEntryQuery,
+                        new String[]{"SHARED_ID"})) {
+
+                    preparedEntryStatement.setString(1, entry.getType().getName());
+                    preparedEntryStatement.executeUpdate();
+
+                    try (ResultSet generatedKeys = preparedEntryStatement.getGeneratedKeys()) {
+                        if (generatedKeys.next()) {
+                            entry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1)); // set generated ID locally
+                        }
+                    }
+                }
+            }
+        } catch (SQLException e) {
+            LOGGER.error("SQL Error: ", e);
+        }
+    }
+
+    @Override
+    protected void insertIntoFieldTable(List<BibEntry> bibEntries) {
         try {
             // Inserting into FIELD table
             // Coerce to ArrayList in order to use List.get()
-            List<Field> fields = new ArrayList<>(bibEntry.getFields());
+            List<List<Field>> fields = bibEntries.stream().map(entry -> new ArrayList<>(entry.getFields()))
+                    .collect(Collectors.toList());
             StringBuilder insertFieldQuery = new StringBuilder()
                     .append("INSERT ALL");
-            for (Field field : fields) {
+            int numFields = 0;
+            for (List<Field> entryFields : fields) {
+                numFields += entryFields.size();
+            }
+            for (int i = 0; i < numFields; i++) {
                 insertFieldQuery.append(" INTO ")
                                 .append(escape("FIELD"))
                                 .append(" (")
@@ -123,14 +159,17 @@ protected void insertIntoFieldTable(BibEntry bibEntry) {
             }
             insertFieldQuery.append(" SELECT * FROM DUAL");
             try (PreparedStatement preparedFieldStatement = connection.prepareStatement(insertFieldQuery.toString())) {
-                for (int i = 0; i < fields.size(); i++) {
-                    // columnIndex starts with 1
-                    preparedFieldStatement.setInt((3 * i) + 1, bibEntry.getSharedBibEntryData().getSharedID());
-                    preparedFieldStatement.setString((3 * i) + 2, fields.get(i).getName());
-                    preparedFieldStatement.setString((3 * i) + 3, bibEntry.getField(fields.get(i)).get());
+                int fieldsCompleted = 0;
+                for (int entryIndex = 0; entryIndex < fields.size(); entryIndex++) {
+                    for (int entryFieldsIndex = 0; entryFieldsIndex < fields.get(entryIndex).size(); entryFieldsIndex++) {
+                        // columnIndex starts with 1
+                        preparedFieldStatement.setInt((3 * fieldsCompleted) + 1, bibEntries.get(entryIndex).getSharedBibEntryData().getSharedID());
+                        preparedFieldStatement.setString((3 * fieldsCompleted) + 2, fields.get(entryIndex).get(entryFieldsIndex).getName());
+                        preparedFieldStatement.setString((3 * fieldsCompleted) + 3, bibEntries.get(entryIndex).getField(fields.get(entryIndex).get(entryFieldsIndex)).get());
+                        fieldsCompleted += 1;
+                    }
                 }
-                preparedFieldStatement.executeUpdate();
-            }
+                preparedFieldStatement.executeUpdate();            }
         } catch (SQLException e) {
             LOGGER.error("SQL Error: ", e);
         }
diff --git a/src/main/java/org/jabref/logic/shared/PostgreSQLProcessor.java b/src/main/java/org/jabref/logic/shared/PostgreSQLProcessor.java
index 26cb1adfd01..ad53d54fd3b 100644
--- a/src/main/java/org/jabref/logic/shared/PostgreSQLProcessor.java
+++ b/src/main/java/org/jabref/logic/shared/PostgreSQLProcessor.java
@@ -4,6 +4,7 @@
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.sql.Statement;
+import java.util.List;
 
 import org.jabref.JabRefExecutorService;
 import org.jabref.logic.shared.listener.PostgresSQLNotificationListener;
@@ -49,25 +50,33 @@ public void setUp() throws SQLException {
     }
 
     @Override
-    protected void insertIntoEntryTable(BibEntry bibEntry) {
-        // Inserting into ENTRY table
+    protected void insertIntoEntryTable(List<BibEntry> bibEntries) {
         StringBuilder insertIntoEntryQuery = new StringBuilder()
-                                                                .append("INSERT INTO ")
-                                                                .append(escape("ENTRY"))
-                                                                .append("(")
-                                                                .append(escape("TYPE"))
-                                                                .append(") VALUES(?)");
-
-        // This is the only method to get generated keys which is accepted by MySQL, PostgreSQL and Oracle.
+                .append("INSERT INTO ")
+                .append(escape("ENTRY"))
+                .append("(")
+                .append(escape("TYPE"))
+                .append(") VALUES(?)");
+        // Number of commas is bibEntries.size() - 1
+        for (int i = 0; i < bibEntries.size() - 1; i++) {
+            insertIntoEntryQuery.append(", (?)");
+        }
         try (PreparedStatement preparedEntryStatement = connection.prepareStatement(insertIntoEntryQuery.toString(),
-                                                                                    Statement.RETURN_GENERATED_KEYS)) {
-
-            preparedEntryStatement.setString(1, bibEntry.getType().getName());
+                Statement.RETURN_GENERATED_KEYS)) {
+            for (int i = 0; i < bibEntries.size(); i++) {
+                preparedEntryStatement.setString(i + 1, bibEntries.get(i).getType().getName());
+            }
             preparedEntryStatement.executeUpdate();
 
             try (ResultSet generatedKeys = preparedEntryStatement.getGeneratedKeys()) {
+                // The following assumes that we get the generated keys in the order the entries were inserted
+                // This should be the case
+                for (BibEntry bibEntry : bibEntries) {
+                    generatedKeys.next();
+                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1));
+                }
                 if (generatedKeys.next()) {
-                    bibEntry.getSharedBibEntryData().setSharedID(generatedKeys.getInt(1)); // set generated ID locally
+                    LOGGER.error("Error: Some shared IDs left unassigned");
                 }
             }
         } catch (SQLException e) {
diff --git a/src/main/resources/l10n/JabRef_en.properties b/src/main/resources/l10n/JabRef_en.properties
index 683ef68d916..0e357ac8784 100644
--- a/src/main/resources/l10n/JabRef_en.properties
+++ b/src/main/resources/l10n/JabRef_en.properties
@@ -2096,6 +2096,13 @@ Escape\ ampersands=Escape ampersands
 Copied\ '%0'\ to\ clipboard.=Copied '%0' to clipboard.
 This\ operation\ requires\ exactly\ an\ open\ library.=This operation requires exactly an open library.
 
+Plain\ References\ Parser=Plain References Parser
+Please\ enter\ the\ plain\ references\ to\ extract\ from\ separated\ by\ double\ empty\ lines.=Please enter the plain references to extract from separated by double empty lines.
+Add\ to\ current\ library=Add to current library
+%0\ entries\ were\ parsed\ from\ your\ query.=%0 entries were parsed from your query.
+Starts\ the\ extraction\ and\ adds\ the\ resulting\ entries\ to\ the\ currently\ opened\ database=Starts the extraction and adds the resulting entries to the currently opened database
+Your\ text\ is\ being\ parsed...=Your text is being parsed...
+
 BibTeX\ key\ filters=BibTeX key filters
 Field\ filters=Field filters
 Message\ filters=Message filters
diff --git a/src/test/java/org/jabref/logic/importer/fetcher/DBLPFetcherTest.java b/src/test/java/org/jabref/logic/importer/fetcher/DBLPFetcherTest.java
index 8aa622253aa..8cd70f8e345 100644
--- a/src/test/java/org/jabref/logic/importer/fetcher/DBLPFetcherTest.java
+++ b/src/test/java/org/jabref/logic/importer/fetcher/DBLPFetcherTest.java
@@ -44,7 +44,7 @@ public void setUp() {
         entry.setField(StandardField.YEAR, "2016");
         entry.setField(StandardField.URL,
                 "http://pi.informatik.uni-siegen.de/stt/36_2/./03_Technische_Beitraege/ZEUS2016/beitrag_2.pdf");
-        entry.setField(new UnknownField("biburl"), "{https://dblp.org/rec/journals/stt/GeigerHL16.bib");
+        entry.setField(new UnknownField("biburl"), "https://dblp.org/rec/journals/stt/GeigerHL16.bib");
         entry.setField(new UnknownField("bibsource"), "dblp computer science bibliography, https://dblp.org");
     }
 
diff --git a/src/test/java/org/jabref/logic/importer/fetcher/GrobidCitationFetcherTest.java b/src/test/java/org/jabref/logic/importer/fetcher/GrobidCitationFetcherTest.java
new file mode 100644
index 00000000000..c3075747a1e
--- /dev/null
+++ b/src/test/java/org/jabref/logic/importer/fetcher/GrobidCitationFetcherTest.java
@@ -0,0 +1,88 @@
+package org.jabref.logic.importer.fetcher;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.jabref.logic.importer.ImportFormatPreferences;
+import org.jabref.model.entry.BibEntry;
+import org.jabref.model.entry.field.StandardField;
+import org.jabref.model.entry.types.StandardEntryType;
+import org.jabref.testutils.category.FetcherTest;
+
+import org.junit.jupiter.api.Test;
+import org.mockito.Answers;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+
+@FetcherTest
+public class GrobidCitationFetcherTest {
+
+    static ImportFormatPreferences importFormatPreferences = mock(ImportFormatPreferences.class, Answers.RETURNS_DEEP_STUBS);
+    static GrobidCitationFetcher grobidCitationFetcher = new GrobidCitationFetcher(importFormatPreferences);
+
+    static String example1 = "Derwing, T. M., Rossiter, M. J., & Munro, M. J. (2002). Teaching native speakers to listen to foreign-accented speech. Journal of Multilingual and Multicultural Development, 23(4), 245-259.";
+    static BibEntry example1AsBibEntry = new BibEntry(StandardEntryType.Article).withCiteKey("-1")
+                .withField(StandardField.AUTHOR, "T Derwing and M Rossiter and M Munro")
+                .withField(StandardField.TITLE, "Teaching native speakers to listen to foreign-accented speech")
+                .withField(StandardField.JOURNAL, "Journal of Multilingual and Multicultural Development")
+                .withField(StandardField.YEAR, "2002")
+                .withField(StandardField.PAGES, "245--259")
+                .withField(StandardField.VOLUME, "23")
+                .withField(StandardField.NUMBER, "4");
+    static String example2 = "Thomas, H. K. (2004). Training strategies for improving listeners' comprehension of foreign-accented speech (Doctoral dissertation). University of Colorado, Boulder.";
+    static BibEntry example2AsBibEntry = new BibEntry(BibEntry.DEFAULT_TYPE).withCiteKey("-1")
+            .withField(StandardField.AUTHOR, "H Thomas")
+            .withField(StandardField.TITLE, "Training strategies for improving listeners' comprehension of foreign-accented speech (Doctoral dissertation)")
+            .withField(StandardField.YEAR, "2004")
+            .withField(StandardField.ADDRESS, "Boulder");
+    static String example3 = "Turk, J., Graham, P., & Verhulst, F. (2007). Child and adolescent psychiatry : A developmental approach. Oxford, England: Oxford University Press.";
+    static BibEntry example3AsBibEntry = new BibEntry(BibEntry.DEFAULT_TYPE).withCiteKey("-1")
+            .withField(StandardField.AUTHOR, "J Turk and P Graham and F Verhulst")
+            .withField(StandardField.TITLE, "Child and adolescent psychiatry : A developmental approach")
+            .withField(StandardField.PUBLISHER, "Oxford University Press")
+            .withField(StandardField.YEAR, "2007")
+            .withField(StandardField.ADDRESS, "Oxford, England");
+    static String example4 = "Carr, I., & Kidner, R. (2003). Statutes and conventions on international trade law (4th ed.). London, England: Cavendish.";
+    static BibEntry example4AsBibEntry = new BibEntry(StandardEntryType.Article).withCiteKey("-1")
+            .withField(StandardField.AUTHOR, "I Carr and R Kidner")
+            .withField(StandardField.BOOKTITLE, "Statutes and conventions on international trade law")
+            .withField(StandardField.PUBLISHER, "Cavendish")
+            .withField(StandardField.YEAR, "2003")
+            .withField(StandardField.ADDRESS, "London, England");
+    static String invalidInput1 = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx________________________________";
+    static String invalidInput2 = "¦@#¦@#¦@#¦@#¦@#¦@#¦@°#¦@¦°¦@°";
+
+    @Test
+    public void grobidPerformSearchCorrectResultTest() {
+        List<BibEntry> entries = grobidCitationFetcher.performSearch(example1);
+        assertEquals(List.of(example1AsBibEntry), entries);
+        entries = grobidCitationFetcher.performSearch(example2);
+        assertEquals(List.of(example2AsBibEntry), entries);
+        entries = grobidCitationFetcher.performSearch(example3);
+        assertEquals(List.of(example3AsBibEntry), entries);
+        entries = grobidCitationFetcher.performSearch(example4);
+        assertEquals(List.of(example4AsBibEntry), entries);
+    }
+
+    @Test
+    public void grobidPerformSearchCorrectlySplitsStringTest() {
+        List<BibEntry> entries = grobidCitationFetcher.performSearch(example1 + "\n\n" + example2 + "\r\n\r\n" + example3 + "\r\r" + example4);
+        assertEquals(List.of(example1AsBibEntry, example2AsBibEntry, example3AsBibEntry, example4AsBibEntry), entries);
+    }
+
+    @Test
+    public void grobidPerformSearchWithEmptyStringsTest() {
+        List<BibEntry> entries = grobidCitationFetcher.performSearch("   \n   ");
+        assertEquals(Collections.emptyList(), entries);
+    }
+
+    @Test
+    public void grobidPerformSearchWithInvalidDataTest() {
+        List<BibEntry> entries = grobidCitationFetcher.performSearch(invalidInput1);
+        assertEquals(Collections.emptyList(), entries);
+        entries = grobidCitationFetcher.performSearch(invalidInput2);
+        assertEquals(Collections.emptyList(), entries);
+    }
+
+}
diff --git a/src/test/java/org/jabref/logic/importer/util/GrobidServiceTest.java b/src/test/java/org/jabref/logic/importer/util/GrobidServiceTest.java
new file mode 100644
index 00000000000..75a0cf902be
--- /dev/null
+++ b/src/test/java/org/jabref/logic/importer/util/GrobidServiceTest.java
@@ -0,0 +1,54 @@
+package org.jabref.logic.importer.util;
+
+import java.io.IOException;
+
+import org.jabref.testutils.category.FetcherTest;
+
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@FetcherTest
+public class GrobidServiceTest {
+
+    private static GrobidService grobidService;
+
+    @BeforeAll
+    public static void setup() {
+        grobidService = new GrobidService("http://grobid.cm.in.tum.de:8070");
+    }
+
+    @Test
+    public void processValidCitationTest() throws IOException {
+        String response = grobidService.processCitation("Derwing, T. M., Rossiter, M. J., & Munro, " +
+                "M. J. (2002). Teaching native speakers to listen to foreign-accented speech. " +
+                "Journal of Multilingual and Multicultural Development, 23(4), 245-259.", GrobidService.ConsolidateCitations.WITH_METADATA);
+        String[] responseRows = response.split("\n");
+        assertNotNull(response);
+        assertEquals('@', response.charAt(0));
+        assertTrue(responseRows[1].contains("author") && responseRows[1].contains("Derwing and M Rossiter"));
+        assertTrue(responseRows[2].contains("title") && responseRows[2].contains("Teaching native speakers"));
+        assertTrue(responseRows[3].contains("journal") && responseRows[3].contains("Journal of Multilingual and Multicultural"));
+        assertTrue(responseRows[4].contains("year") && responseRows[4].contains("2002"));
+        assertTrue(responseRows[5].contains("pages") && responseRows[5].contains("245--259"));
+        assertTrue(responseRows[6].contains("volume") && responseRows[6].contains("23"));
+        assertTrue(responseRows[7].contains("number") && responseRows[7].contains("4"));
+    }
+
+    @Test
+    public void processEmptyStringTest() throws IOException {
+        String response = grobidService.processCitation(" ", GrobidService.ConsolidateCitations.WITH_METADATA);
+        assertNotNull(response);
+        assertEquals("", response);
+    }
+
+    @Test
+    public void processInvalidCitationTest() {
+        assertThrows(IOException.class, () -> grobidService.processCitation("iiiiiiiiiiiiiiiiiiiiiiii", GrobidService.ConsolidateCitations.WITH_METADATA));
+    }
+
+}
diff --git a/src/test/java/org/jabref/logic/shared/DBMSProcessorTest.java b/src/test/java/org/jabref/logic/shared/DBMSProcessorTest.java
index 754e601e0b2..fe7c59b4263 100644
--- a/src/test/java/org/jabref/logic/shared/DBMSProcessorTest.java
+++ b/src/test/java/org/jabref/logic/shared/DBMSProcessorTest.java
@@ -2,6 +2,7 @@
 
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
@@ -70,7 +71,7 @@ void testInsertEntry() throws SQLException {
 
         dbmsProcessor.insertEntry(expectedEntry);
 
-        BibEntry emptyEntry = new BibEntry();
+        BibEntry emptyEntry = getBibEntryExample();
         emptyEntry.getSharedBibEntryData().setSharedID(1);
         dbmsProcessor.insertEntry(emptyEntry); // does not insert, due to same sharedID.
 
@@ -97,31 +98,37 @@ void testInsertEntry() throws SQLException {
 
     @Test
     void testInsertMultipleEntries() throws SQLException {
-        BibEntry firstEntry = getBibEntryExample();
-        String firstId = firstEntry.getId();
-        BibEntry secondEntry = getBibEntryExample2();
-        String secondId = secondEntry.getId();
-        BibEntry thirdEntry = getBibEntryExample3();
-        String thirdId = thirdEntry.getId();
-
-        // This must eventually be changed to insertEntries() once that method is implemented
-        dbmsProcessor.insertEntry(firstEntry);
-        dbmsProcessor.insertEntry(secondEntry);
-        dbmsProcessor.insertEntry(thirdEntry);
+        List<BibEntry> entries = new ArrayList<>();
+        for (int i = 0; i < 5; i++) {
+            entries.add(new BibEntry(StandardEntryType.Article).withField(StandardField.JOURNAL, "journal " + i)
+            .withField(StandardField.ISSUE, Integer.toString(i)));
+        }
+        entries.get(3).setType(StandardEntryType.Thesis);
+        dbmsProcessor.insertEntries(entries);
 
         Map<Integer, Map<String, String>> actualFieldMap = new HashMap<>();
 
         try (ResultSet entryResultSet = selectFrom("ENTRY", dbmsConnection, dbmsProcessor)) {
             assertTrue(entryResultSet.next());
             assertEquals(1, entryResultSet.getInt("SHARED_ID"));
-            assertEquals("inproceedings", entryResultSet.getString("TYPE"));
+            assertEquals("article", entryResultSet.getString("TYPE"));
             assertEquals(1, entryResultSet.getInt("VERSION"));
             assertTrue(entryResultSet.next());
             assertEquals(2, entryResultSet.getInt("SHARED_ID"));
-            assertEquals("inproceedings", entryResultSet.getString("TYPE"));
+            assertEquals("article", entryResultSet.getString("TYPE"));
             assertEquals(1, entryResultSet.getInt("VERSION"));
             assertTrue(entryResultSet.next());
             assertEquals(3, entryResultSet.getInt("SHARED_ID"));
+            assertEquals("article", entryResultSet.getString("TYPE"));
+            assertEquals(1, entryResultSet.getInt("VERSION"));
+            assertTrue(entryResultSet.next());
+            assertEquals(4, entryResultSet.getInt("SHARED_ID"));
+            assertEquals("thesis", entryResultSet.getString("TYPE"));
+            assertEquals(1, entryResultSet.getInt("VERSION"));
+            assertTrue(entryResultSet.next());
+            assertEquals(5, entryResultSet.getInt("SHARED_ID"));
+            assertEquals("article", entryResultSet.getString("TYPE"));
+            assertEquals(1, entryResultSet.getInt("VERSION"));
             assertFalse(entryResultSet.next());
 
             try (ResultSet fieldResultSet = selectFrom("FIELD", dbmsConnection, dbmsProcessor)) {
@@ -139,7 +146,6 @@ void testInsertMultipleEntries() throws SQLException {
                 }
             }
         }
-        List<BibEntry> entries = Arrays.asList(firstEntry, secondEntry, thirdEntry);
         Map<Integer, Map<String, String>> expectedFieldMap = entries.stream()
                                                                    .collect(Collectors.toMap(bibEntry -> bibEntry.getSharedBibEntryData().getSharedID(),
                                                                            (bibEntry) -> bibEntry.getFieldMap().entrySet().stream()
diff --git a/src/test/java/org/jabref/logic/shared/TestConnector.java b/src/test/java/org/jabref/logic/shared/TestConnector.java
index 73d7d9b9a8a..f48bb98e422 100644
--- a/src/test/java/org/jabref/logic/shared/TestConnector.java
+++ b/src/test/java/org/jabref/logic/shared/TestConnector.java
@@ -24,7 +24,7 @@ public static DBMSConnectionProperties getTestConnectionProperties(DBMSType dbms
             case POSTGRESQL:
                 return new DBMSConnectionPropertiesBuilder().setType(dbmsType).setHost("localhost").setPort(dbmsType.getDefaultPort()).setDatabase("postgres").setUser("postgres").setPassword("postgres").setUseSSL(false).createDBMSConnectionProperties();
             case ORACLE:
-                return new DBMSConnectionPropertiesBuilder().setType(dbmsType).setHost("localhost").setPort(dbmsType.getDefaultPort()).setDatabase("jabref").setUser("jabref").setPassword("jabref").setUseSSL(false).setPort(32118).createDBMSConnectionProperties();
+                return new DBMSConnectionPropertiesBuilder().setType(dbmsType).setHost("localhost").setPort(32118).setDatabase("jabref").setUser("jabref").setPassword("jabref").setUseSSL(false).createDBMSConnectionProperties();
             default:
                 return new DBMSConnectionPropertiesBuilder().createDBMSConnectionProperties();
         }