diff --git a/Roadmap for GBIF vocabularies.pdf b/Roadmap for GBIF vocabularies.pdf
new file mode 100644
index 00000000..2c1a9ad6
Binary files /dev/null and b/Roadmap for GBIF vocabularies.pdf differ
diff --git a/core/src/main/java/org/gbif/vocabulary/persistence/dto/LookupDto.java b/core/src/main/java/org/gbif/vocabulary/persistence/dto/LookupDto.java
new file mode 100644
index 00000000..e69eea2d
--- /dev/null
+++ b/core/src/main/java/org/gbif/vocabulary/persistence/dto/LookupDto.java
@@ -0,0 +1,16 @@
+package org.gbif.vocabulary.persistence.dto;
+
+import lombok.Data;
+import org.gbif.vocabulary.model.LanguageRegion;
+
+@Data
+public class LookupDto {
+
+  private long key;
+  private String name;
+  private String label;
+  private LanguageRegion labelLang;
+  private String altLabel;
+  private LanguageRegion altLabelLang;
+  private String hiddenLabel;
+}
diff --git a/core/src/main/java/org/gbif/vocabulary/persistence/mappers/ConceptMapper.java b/core/src/main/java/org/gbif/vocabulary/persistence/mappers/ConceptMapper.java
index bf17be3e..5ab80e89 100644
--- a/core/src/main/java/org/gbif/vocabulary/persistence/mappers/ConceptMapper.java
+++ b/core/src/main/java/org/gbif/vocabulary/persistence/mappers/ConceptMapper.java
@@ -13,6 +13,10 @@
  */
 package org.gbif.vocabulary.persistence.mappers;
 
+import java.util.List;
+import javax.annotation.Nullable;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
 import org.gbif.api.model.common.paging.Pageable;
 import org.gbif.vocabulary.model.Concept;
 import org.gbif.vocabulary.model.Definition;
@@ -23,15 +27,9 @@
 import org.gbif.vocabulary.model.search.ChildrenResult;
 import org.gbif.vocabulary.model.search.ConceptSearchParams;
 import org.gbif.vocabulary.model.search.KeyNameResult;
+import org.gbif.vocabulary.persistence.dto.LookupDto;
 import org.gbif.vocabulary.persistence.dto.SuggestDto;
 
-import java.util.List;
-
-import javax.annotation.Nullable;
-
-import org.apache.ibatis.annotations.Mapper;
-import org.apache.ibatis.annotations.Param;
-
 /** Mapper for {@link Concept}. */
 @Mapper
 public interface ConceptMapper extends BaseMapper<Concept> {
@@ -197,4 +195,11 @@ List<HiddenLabel> listHiddenLabelsLatestRelease(
 
   long countHiddenLabelsLatestRelease(
       @Param("entityKey") long entityKey, @Param("vocabName") String vocabularyName);
+
+  List<LookupDto> lookup(@Param("value") String value, @Param("vocabularyKey") long vocabularyKey);
+
+  List<LookupDto> lookupLatestRelease(
+      @Param("value") String value,
+      @Param("vocabularyKey") long vocabularyKey,
+      @Param("vocabName") String vocabularyName);
 }
diff --git a/core/src/main/java/org/gbif/vocabulary/service/ConceptService.java b/core/src/main/java/org/gbif/vocabulary/service/ConceptService.java
index 430d900f..3803a844 100644
--- a/core/src/main/java/org/gbif/vocabulary/service/ConceptService.java
+++ b/core/src/main/java/org/gbif/vocabulary/service/ConceptService.java
@@ -13,6 +13,11 @@
  */
 package org.gbif.vocabulary.service;
 
+import java.util.List;
+import javax.annotation.Nullable;
+import javax.validation.Valid;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
 import org.gbif.api.model.common.paging.Pageable;
 import org.gbif.api.model.common.paging.PagingResponse;
 import org.gbif.vocabulary.model.Concept;
@@ -23,15 +28,9 @@
 import org.gbif.vocabulary.model.Tag;
 import org.gbif.vocabulary.model.search.ChildrenResult;
 import org.gbif.vocabulary.model.search.ConceptSearchParams;
+import org.gbif.vocabulary.model.search.LookupResult;
 import org.gbif.vocabulary.model.search.SuggestResult;
 
-import java.util.List;
-
-import javax.annotation.Nullable;
-import javax.validation.Valid;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-
 /** Services for a {@link Concept}. */
 public interface ConceptService extends BaseService<Concept> {
 
@@ -248,4 +247,26 @@ PagingResponse<Label> listAlternativeLabelsLatestRelease(
    */
   PagingResponse<HiddenLabel> listHiddenLabelsLatestRelease(
       long entityKey, @Nullable Pageable page, String vocabularyName);
+
+  /**
+   * Lookups concepts that match the given value.
+   *
+   * @param value value to match against the concepts
+   * @param vocabularyName vocabulary to use in the lookup
+   * @param languageRegion language to use as discriminator. English is used as fallback.
+   * @return list of the concepts found
+   */
+  List<LookupResult> lookup(
+      String value, String vocabularyName, @Nullable LanguageRegion languageRegion);
+
+  /**
+   * It works as
+   *
+   * @param value value to match against the concepts
+   * @param vocabularyName vocabulary to use in the lookup
+   * @param languageRegion language to use as discriminator. English is used as fallback.
+   * @return list of the concepts found
+   */
+  List<LookupResult> lookupLatestRelease(
+      String value, String vocabularyName, @Nullable LanguageRegion languageRegion);
 }
diff --git a/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultConceptService.java b/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultConceptService.java
index 474826a1..faa2eae3 100644
--- a/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultConceptService.java
+++ b/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultConceptService.java
@@ -13,61 +13,70 @@
  */
 package org.gbif.vocabulary.service.impl;
 
+import static com.google.common.base.Preconditions.checkArgument;
+import static java.util.Objects.requireNonNull;
+import static org.gbif.vocabulary.model.normalizers.StringNormalizer.*;
+
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+import javax.validation.Valid;
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+import javax.validation.groups.Default;
 import org.gbif.api.model.common.paging.Pageable;
 import org.gbif.api.model.common.paging.PagingRequest;
 import org.gbif.api.model.common.paging.PagingResponse;
 import org.gbif.vocabulary.model.*;
 import org.gbif.vocabulary.model.exception.EntityNotFoundException;
+import org.gbif.vocabulary.model.normalizers.StringNormalizer;
 import org.gbif.vocabulary.model.search.ChildrenResult;
 import org.gbif.vocabulary.model.search.ConceptSearchParams;
 import org.gbif.vocabulary.model.search.KeyNameResult;
+import org.gbif.vocabulary.model.search.LookupResult;
 import org.gbif.vocabulary.model.search.SuggestResult;
+import org.gbif.vocabulary.model.utils.PathUtils;
 import org.gbif.vocabulary.model.utils.PostPersist;
 import org.gbif.vocabulary.model.utils.PrePersist;
+import org.gbif.vocabulary.persistence.dto.LookupDto;
 import org.gbif.vocabulary.persistence.dto.ParentDto;
 import org.gbif.vocabulary.persistence.dto.SuggestDto;
 import org.gbif.vocabulary.persistence.mappers.ConceptMapper;
 import org.gbif.vocabulary.persistence.mappers.VocabularyMapper;
 import org.gbif.vocabulary.service.ConceptService;
-
-import java.util.Comparator;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.stream.Collectors;
-
-import javax.annotation.Nullable;
-import javax.validation.Valid;
-import javax.validation.constraints.NotBlank;
-import javax.validation.constraints.NotNull;
-import javax.validation.groups.Default;
-
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.security.access.annotation.Secured;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.validation.annotation.Validated;
 
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static java.util.Objects.requireNonNull;
-import static org.gbif.vocabulary.model.normalizers.StringNormalizer.*;
-
 /** Default implementation for {@link ConceptService}. */
 @Service
 @Validated
 public class DefaultConceptService implements ConceptService {
 
   private static final int DEFAULT_SUGGEST_LIMIT = 20;
+  private static final String CONCEPT_LINK = "%s/vocabularies/%s/concepts/%s";
   private final ConceptMapper conceptMapper;
   private final VocabularyMapper vocabularyMapper;
+  private final String apiUrl;
 
   @Autowired
-  public DefaultConceptService(ConceptMapper conceptMapper, VocabularyMapper vocabularyMapper) {
+  public DefaultConceptService(
+      ConceptMapper conceptMapper,
+      VocabularyMapper vocabularyMapper,
+      @Value("${ws.apiUrl}") String apiUrl) {
     this.conceptMapper = conceptMapper;
     this.vocabularyMapper = vocabularyMapper;
+    this.apiUrl = apiUrl;
   }
 
   @Override
@@ -403,7 +412,10 @@ private void checkSimilarLabels(long entityKey, Label label) {
     long vocabularyKey = conceptMapper.getVocabularyKey(entityKey);
     List<KeyNameResult> similarities =
         conceptMapper.findSimilarities(
-            normalizeLabel(label.getValue()), label.getLanguage(), vocabularyKey, entityKey);
+            replaceNonAsciiCharactersWithEquivalents(normalizeLabel(label.getValue())),
+            label.getLanguage(),
+            vocabularyKey,
+            entityKey);
     if (!similarities.isEmpty()) {
       throw new IllegalArgumentException(
           "Cannot create entity because it conflicts with other entities, e.g.: " + similarities);
@@ -446,7 +458,10 @@ private void checkSimilarHiddenLabels(long entityKey, HiddenLabel label) {
     long vocabularyKey = conceptMapper.getVocabularyKey(entityKey);
     List<KeyNameResult> similarities =
         conceptMapper.findSimilarities(
-            normalizeName(label.getValue()), null, vocabularyKey, entityKey);
+            replaceNonAsciiCharactersWithEquivalents(normalizeName(label.getValue())),
+            null,
+            vocabularyKey,
+            entityKey);
     if (!similarities.isEmpty()) {
       throw new IllegalArgumentException(
           "Cannot create entity because it conflicts with other entities, e.g.: " + similarities);
@@ -563,18 +578,21 @@ public List<ChildrenResult> countChildrenLatestRelease(
   @Override
   public List<Definition> listDefinitionsLatestRelease(
       long entityKey, List<LanguageRegion> languageRegions, String vocabularyName) {
+    checkReleaseExists(vocabularyName);
     return conceptMapper.listDefinitionsLatestRelease(entityKey, languageRegions, vocabularyName);
   }
 
   @Override
   public List<Label> listLabelsLatestRelease(
       long entityKey, List<LanguageRegion> languageRegions, String vocabularyName) {
+    checkReleaseExists(vocabularyName);
     return conceptMapper.listLabelsLatestRelease(entityKey, languageRegions, vocabularyName);
   }
 
   @Override
   public PagingResponse<Label> listAlternativeLabelsLatestRelease(
       long entityKey, List<LanguageRegion> languageRegions, Pageable page, String vocabularyName) {
+    checkReleaseExists(vocabularyName);
     page = page != null ? page : new PagingRequest();
     return new PagingResponse<>(
         page,
@@ -587,6 +605,7 @@ public PagingResponse<Label> listAlternativeLabelsLatestRelease(
   @Override
   public PagingResponse<HiddenLabel> listHiddenLabelsLatestRelease(
       long entityKey, Pageable page, String vocabularyName) {
+    checkReleaseExists(vocabularyName);
     page = page != null ? page : new PagingRequest();
     return new PagingResponse<>(
         page,
@@ -594,6 +613,81 @@ public PagingResponse<HiddenLabel> listHiddenLabelsLatestRelease(
         conceptMapper.listHiddenLabelsLatestRelease(entityKey, page, vocabularyName));
   }
 
+  @Override
+  public List<LookupResult> lookup(
+      String value, String vocabularyName, @Nullable LanguageRegion languageRegion) {
+    return lookupInternal(value, vocabularyName, languageRegion, false);
+  }
+
+  @Override
+  public List<LookupResult> lookupLatestRelease(
+      String value, String vocabularyName, LanguageRegion languageRegion) {
+    checkReleaseExists(vocabularyName);
+    return lookupInternal(value, vocabularyName, languageRegion, true);
+  }
+
+  private List<LookupResult> lookupInternal(
+      String value, String vocabularyName, LanguageRegion languageRegion, boolean latestRelease) {
+    if (Strings.isNullOrEmpty(value)) {
+      return Collections.emptyList();
+    }
+
+    Long vocabularyKey = vocabularyMapper.getKeyByName(vocabularyName);
+    Objects.requireNonNull(vocabularyKey);
+
+    String normalizedValue = StringNormalizer.replaceNonAsciiCharactersWithEquivalents(value);
+    List<LookupDto> dtos = new ArrayList<>();
+    if (latestRelease) {
+      dtos = conceptMapper.lookupLatestRelease(normalizedValue, vocabularyKey, vocabularyName);
+    } else {
+      dtos = conceptMapper.lookup(normalizedValue, vocabularyKey);
+    }
+
+    if (!dtos.isEmpty() && languageRegion != null) {
+      List<LookupDto> dtosByLang =
+          dtos.stream()
+              .filter(
+                  d -> d.getLabelLang() == languageRegion || d.getAltLabelLang() == languageRegion)
+              .collect(Collectors.toList());
+
+      if (dtosByLang.isEmpty()) {
+        // we use English as fallback
+        dtosByLang =
+            dtos.stream()
+                .filter(
+                    d ->
+                        (d.getLabelLang() == null && d.getAltLabelLang() == null)
+                            || d.getLabelLang() == LanguageRegion.ENGLISH
+                            || d.getAltLabelLang() == LanguageRegion.ENGLISH)
+                .collect(Collectors.toList());
+      }
+
+      dtos = dtosByLang;
+    }
+
+    return dtos.stream()
+        .map(
+            d -> {
+              LookupResult lookupResult = new LookupResult();
+              lookupResult.setConceptName(d.getName());
+              lookupResult.setMatchedLabel(d.getLabel());
+              lookupResult.setMatchedLabelLanguage(d.getLabelLang());
+              lookupResult.setMatchedAlternativeLabel(d.getAltLabel());
+              lookupResult.setMatchedAlternativeLabelLanguage(d.getAltLabelLang());
+              lookupResult.setMatchedHiddenLabel(d.getHiddenLabel());
+              lookupResult.setConceptLink(
+                  String.format(
+                      CONCEPT_LINK,
+                      apiUrl,
+                      vocabularyName,
+                      latestRelease
+                          ? PathUtils.LATEST_RELEASE_PATH + "/" + d.getName()
+                          : d.getName()));
+              return lookupResult;
+            })
+        .collect(Collectors.toList());
+  }
+
   private void checkReleaseExists(String vocabularyName) {
     if (!existsLatestReleaseView(vocabularyName)) {
       throw new EntityNotFoundException(
diff --git a/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultExportService.java b/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultExportService.java
index c8631db2..40debdd9 100644
--- a/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultExportService.java
+++ b/core/src/main/java/org/gbif/vocabulary/service/impl/DefaultExportService.java
@@ -13,6 +13,29 @@
  */
 package org.gbif.vocabulary.service.impl;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.core.JsonFactory;
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.databind.SerializationFeature;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
+import javax.validation.constraints.NotBlank;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
 import org.gbif.api.model.common.paging.Pageable;
 import org.gbif.api.model.common.paging.PagingRequest;
 import org.gbif.api.model.common.paging.PagingResponse;
@@ -20,6 +43,7 @@
 import org.gbif.vocabulary.model.Definition;
 import org.gbif.vocabulary.model.HiddenLabel;
 import org.gbif.vocabulary.model.Label;
+import org.gbif.vocabulary.model.Tag;
 import org.gbif.vocabulary.model.UserRoles;
 import org.gbif.vocabulary.model.Vocabulary;
 import org.gbif.vocabulary.model.VocabularyRelease;
@@ -34,39 +58,11 @@
 import org.gbif.vocabulary.service.ExportService;
 import org.gbif.vocabulary.service.VocabularyService;
 import org.gbif.vocabulary.service.export.ReleasePersister;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.time.LocalDateTime;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Optional;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import javax.annotation.Nullable;
-import javax.validation.constraints.NotBlank;
-
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.security.access.annotation.Secured;
 import org.springframework.stereotype.Service;
 import org.springframework.validation.annotation.Validated;
 
-import com.fasterxml.jackson.annotation.JsonIgnore;
-import com.fasterxml.jackson.core.JsonFactory;
-import com.fasterxml.jackson.core.JsonGenerator;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.databind.SerializationFeature;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-import com.google.common.annotations.VisibleForTesting;
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
-
-import lombok.SneakyThrows;
-import lombok.extern.slf4j.Slf4j;
-
 /** Default implementation for {@link ExportService}. */
 @Service
 @Validated
@@ -307,6 +303,9 @@ private ConceptExportView getConceptExportView(Concept concept) {
         .getDefinition()
         .forEach(d -> conceptExportView.getDefinition().put(d.getLanguage(), d.getValue()));
 
+    // tags
+    concept.getTags().forEach(t -> conceptExportView.getTags().add(t.getName()));
+
     // labels
     List<Label> labels = conceptService.listLabels(concept.getKey(), null);
     labels.forEach(l -> conceptExportView.getLabel().put(l.getLanguage(), l.getValue()));
@@ -357,5 +356,6 @@ private abstract class VocabularyMixin {
   private abstract class ConceptMixin {
     @JsonIgnore private List<Definition> definition;
     @JsonIgnore private List<Label> label;
+    @JsonIgnore private List<Tag> tags;
   }
 }
diff --git a/core/src/main/resources/liquibase/014-ascii-normalize-function.xml b/core/src/main/resources/liquibase/014-ascii-normalize-function.xml
new file mode 100644
index 00000000..027cade1
--- /dev/null
+++ b/core/src/main/resources/liquibase/014-ascii-normalize-function.xml
@@ -0,0 +1,308 @@
+<databaseChangeLog
+    xmlns="http://www.liquibase.org/xml/ns/dbchangelog"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://www.liquibase.org/xml/ns/dbchangelog http://www.liquibase.org/xml/ns/dbchangelog/dbchangelog-2.0.xsd">
+
+  <!-- same as the AsciiParser class -->
+  <changeSet id="14" author="mlopez">
+    <sql splitStatements="false" stripComments="false">
+      <![CDATA[
+        CREATE OR REPLACE FUNCTION ascii_normalizer(input text)
+        RETURNS text AS
+        $func$
+          DECLARE
+            tmp text;
+            length integer;
+          BEGIN
+            length := char_length(trim(input));
+            IF (length IS NULL) OR (length = 0) OR (input ~ '^[[:ascii:]]+$') THEN
+              RETURN input;
+            ELSE
+              tmp := regexp_replace(input, '(\u00C0|\u00C1|\u00C2|\u00C3|\u00C4|\u00C5|\u0100|\u0102|\u0104|\u018F|\u01CD|\u01DE|\u01E0|\u01FA|\u0200|\u0202|\u0226|\u023A|\u1D00|\u1E00|\u1EA0|\u1EA2|\u1EA4|\u1EA6|\u1EA8|\u1EAA|\u1EAC|\u1EAE|\u1EB0|\u1EB2|\u1EB4|\u1EB6|\u24B6|\uFF21)', 'A', 'g');
+              tmp := regexp_replace(tmp, '(\u00E0|\u00E1|\u00E2|\u00E3|\u00E4|\u00E5|\u0101|\u0103|\u0105|\u01CE|\u01DF|\u01E1|\u01FB|\u0201|\u0203|\u0227|\u0250|\u0259|\u025A|\u1D8F|\u1D95|\u1E01|\u1E9A|\u1EA1|\u1EA3|\u1EA5|\u1EA7|\u1EA9|\u1EAB|\u1EAD|\u1EAF|\u1EB1|\u1EB3|\u1EB5|\u1EB7|\u2090|\u2094|\u24D0|\u2C65|\u2C6F|\uFF41)', 'a', 'g');
+              tmp := regexp_replace(tmp, '(\uA732)', 'AA', 'g');
+              tmp := regexp_replace(tmp, '(\u00C6|\u01E2|\u01FC|\u1D01)', 'AE', 'g');
+              tmp := regexp_replace(tmp, '(\uA734)', 'AO', 'g');
+              tmp := regexp_replace(tmp, '(\uA736)', 'AU', 'g');
+              tmp := regexp_replace(tmp, '(\uA738|\uA73A)', 'AV', 'g');
+              tmp := regexp_replace(tmp, '(\uA73C)', 'AY', 'g');
+              tmp := regexp_replace(tmp, '(\u249C)', '(a)', 'g');
+              tmp := regexp_replace(tmp, '(\uA733)', 'aa', 'g');
+              tmp := regexp_replace(tmp, '(\u00E6|\u01E3|\u01FD|\u1D02)', 'ae', 'g');
+              tmp := regexp_replace(tmp, '(\uA735)', 'ao', 'g');
+              tmp := regexp_replace(tmp, '(\uA737)', 'au', 'g');
+              tmp := regexp_replace(tmp, '(\uA739|\uA73B)', 'av', 'g');
+              tmp := regexp_replace(tmp, '(\uA73D)', 'ay', 'g');
+              tmp := regexp_replace(tmp, '(\u0181|\u0182|\u0243|\u0299|\u1D03|\u1E02|\u1E04|\u1E06|\u24B7|\uFF22)', 'B', 'g');
+              tmp := regexp_replace(tmp, '(\u0180|\u0183|\u0253|\u1D6C|\u1D80|\u1E03|\u1E05|\u1E07|\u24D1|\uFF42)', 'b', 'g');
+              tmp := regexp_replace(tmp, '(\u249D)', '(b)', 'g');
+              tmp := regexp_replace(tmp, '(\u00C7|\u0106|\u0108|\u010A|\u010C|\u0187|\u023B|\u0297|\u1D04|\u1E08|\u24B8|\uFF23)', 'C', 'g');
+              tmp := regexp_replace(tmp, '(\u00E7|\u0107|\u0109|\u010B|\u010D|\u0188|\u023C|\u0255|\u1E09|\u2184|\u24D2|\uA73E|\uA73F|\uFF43)', 'c', 'g');
+              tmp := regexp_replace(tmp, '(\u249E)', '(c)', 'g');
+              tmp := regexp_replace(tmp, '(\u00D0|\u010E|\u0110|\u0189|\u018A|\u018B|\u1D05|\u1D06|\u1E0A|\u1E0C|\u1E0E|\u1E10|\u1E12|\u24B9|\uA779|\uFF24)', 'D', 'g');
+              tmp := regexp_replace(tmp, '(\u00F0|\u010F|\u0111|\u018C|\u0221|\u0256|\u0257|\u1D6D|\u1D81|\u1D91|\u1E0B|\u1E0D|\u1E0F|\u1E11|\u1E13|\u24D3|\uA77A|\uFF44)', 'd', 'g');
+              tmp := regexp_replace(tmp, '(\u01C4|\u01F1)', 'DZ', 'g');
+              tmp := regexp_replace(tmp, '(\u01C5|\u01F2)', 'Dz', 'g');
+              tmp := regexp_replace(tmp, '(\u0238)', 'db', 'g');
+              tmp := regexp_replace(tmp, '(\u01C6|\u01F3|\u02A3|\u02A5)', 'dz', 'g');
+              tmp := regexp_replace(tmp, '(\u00C8|\u00C9|\u00CA|\u00CB|\u0112|\u0114|\u0116|\u0118|\u011A|\u018E|\u0190|\u0204|\u0206|\u0228|\u0246|\u1D07|\u1E14|\u1E16|\u1E18|\u1E1A|\u1E1C|\u1EB8|\u1EBA|\u1EBC|\u1EBE|\u1EC0|\u1EC2|\u1EC4|\u1EC6|\u24BA|\u2C7B|\uFF25)', 'E', 'g');
+              tmp := regexp_replace(tmp, '(\u00E8|\u00E9|\u00EA|\u00EB|\u0113|\u0115|\u0117|\u0119|\u011B|\u01DD|\u0205|\u0207|\u0229|\u0247|\u0258|\u025B|\u025C|\u025D|\u025E|\u029A|\u1D08|\u1D92|\u1D93|\u1D94|\u1E15|\u1E17|\u1E19|\u1E1B|\u1E1D|\u1EB9|\u1EBB|\u1EBD|\u1EBF|\u1EC1|\u1EC3|\u1EC5|\u1EC7|\u2091|\u24D4|\u2C78|\uFF45)', 'e', 'g');
+              tmp := regexp_replace(tmp, '(\u24A0)', '(e)', 'g');
+              tmp := regexp_replace(tmp, '(\u0191|\u1E1E|\u24BB|\uA730|\uA77B|\uA7FB|\uFF26)', 'F', 'g');
+              tmp := regexp_replace(tmp, '(\u0192|\u1D6E|\u1D82|\u1E1F|\u1E9B|\u24D5|\uA77C|\uFF46)', 'f', 'g');
+              tmp := regexp_replace(tmp, '(\u24A1)', '(f)', 'g');
+              tmp := regexp_replace(tmp, '(\uFB00)', 'ff', 'g');
+              tmp := regexp_replace(tmp, '(\uFB03)', 'ffi', 'g');
+              tmp := regexp_replace(tmp, '(\uFB04)', 'ffl', 'g');
+              tmp := regexp_replace(tmp, '(\uFB01)', 'fi', 'g');
+              tmp := regexp_replace(tmp, '(\uFB02)', 'fl', 'g');
+              tmp := regexp_replace(tmp, '(\u011C|\u011E|\u0120|\u0122|\u0193|\u01E4|\u01E5|\u01E6|\u01E7|\u01F4|\u0262|\u029B|\u1E20|\u24BC|\uA77D|\uA77E|\uFF27)', 'G', 'g');
+              tmp := regexp_replace(tmp, '(\u011D|\u011F|\u0121|\u0123|\u01F5|\u0260|\u0261|\u1D77|\u1D79|\u1D83|\u1E21|\u24D6|\uA77F|\uFF47)', 'g', 'g');
+              tmp := regexp_replace(tmp, '(\u24A2)', '(g)', 'g');
+              tmp := regexp_replace(tmp, '(\u0124|\u0126|\u021E|\u029C|\u1E22|\u1E24|\u1E26|\u1E28|\u1E2A|\u24BD|\u2C67|\u2C75|\uFF28)', 'H', 'g');
+              tmp := regexp_replace(tmp, '(\u0125|\u0127|\u021F|\u0265|\u0266|\u02AE|\u02AF|\u1E23|\u1E25|\u1E27|\u1E29|\u1E2B|\u1E96|\u24D7|\u2C68|\u2C76|\uFF48)', 'h', 'g');
+              tmp := regexp_replace(tmp, '(\u01F6)', 'HV', 'g');
+              tmp := regexp_replace(tmp, '(\u24A3)', '(h)', 'g');
+              tmp := regexp_replace(tmp, '(\u0195)', 'hv', 'g');
+              tmp := regexp_replace(tmp, '(\u00CC|\u00CD|\u00CE|\u00CF|\u0128|\u012A|\u012C|\u012E|\u0130|\u0196|\u0197|\u01CF|\u0208|\u020A|\u026A|\u1D7B|\u1E2C|\u1E2E|\u1EC8|\u1ECA|\u24BE|\uA7FE|\uFF29)', 'I', 'g');
+              tmp := regexp_replace(tmp, '(\u00EC|\u00ED|\u00EE|\u00EF|\u0129|\u012B|\u012D|\u012F|\u0131|\u01D0|\u0209|\u020B|\u0268|\u1D09|\u1D62|\u1D7C|\u1D96|\u1E2D|\u1E2F|\u1EC9|\u1ECB|\u2071|\u24D8|\uFF49)', 'i', 'g');
+              tmp := regexp_replace(tmp, '(\u0132)', 'IJ', 'g');
+              tmp := regexp_replace(tmp, '(\u24A4)', '(i)', 'g');
+              tmp := regexp_replace(tmp, '(\u0133)', 'ij', 'g');
+              tmp := regexp_replace(tmp, '(\u0134|\u0248|\u1D0A|\u24BF|\uFF2A)', 'J', 'g');
+              tmp := regexp_replace(tmp, '(\u0135|\u01F0|\u0237|\u0249|\u025F|\u0284|\u029D|\u24D9|\u2C7C|\uFF4A)', 'j', 'g');
+              tmp := regexp_replace(tmp, '(\u24A5)', '(j)', 'g');
+              tmp := regexp_replace(tmp, '(\u0136|\u0198|\u01E8|\u1D0B|\u1E30|\u1E32|\u1E34|\u24C0|\u2C69|\uA740|\uA742|\uA744|\uFF2B)', 'K', 'g');
+              tmp := regexp_replace(tmp, '(\u0137|\u0199|\u01E9|\u029E|\u1D84|\u1E31|\u1E33|\u1E35|\u24DA|\u2C6A|\uA741|\uA743|\uA745|\uFF4B)', 'k', 'g');
+              tmp := regexp_replace(tmp, '(\u24A6)', '(k)', 'g');
+              tmp := regexp_replace(tmp, '(\u0139|\u013B|\u013D|\u013F|\u0141|\u023D|\u029F|\u1D0C|\u1E36|\u1E38|\u1E3A|\u1E3C|\u24C1|\u2C60|\u2C62|\uA746|\uA748|\uA780|\uFF2C)', 'L', 'g');
+              tmp := regexp_replace(tmp, '(\u013A|\u013C|\u013E|\u0140|\u0142|\u019A|\u0234|\u026B|\u026C|\u026D|\u1D85|\u1E37|\u1E39|\u1E3B|\u1E3D|\u24DB|\u2C61|\uA747|\uA749|\uA781|\uFF4C)', 'l', 'g');
+              tmp := regexp_replace(tmp, '(\u01C7)', 'LJ', 'g');
+              tmp := regexp_replace(tmp, '(\u1EFA)', 'LL', 'g');
+              tmp := regexp_replace(tmp, '(\u01C8)', 'Lj', 'g');
+              tmp := regexp_replace(tmp, '(\u24A7)', '(l)', 'g');
+              tmp := regexp_replace(tmp, '(\u01C9)', 'lj', 'g');
+              tmp := regexp_replace(tmp, '(\u1EFB)', 'll', 'g');
+              tmp := regexp_replace(tmp, '(\u02AA)', 'ls', 'g');
+              tmp := regexp_replace(tmp, '(\u02AB)', 'lz', 'g');
+              tmp := regexp_replace(tmp, '(\u019C|\u1D0D|\u1E3E|\u1E40|\u1E42|\u24C2|\u2C6E|\uA7FD|\uA7FF|\uFF2D)', 'M', 'g');
+              tmp := regexp_replace(tmp, '(\u026F|\u0270|\u0271|\u1D6F|\u1D86|\u1E3F|\u1E41|\u1E43|\u24DC|\uFF4D)', 'm', 'g');
+              tmp := regexp_replace(tmp, '(\u24A8)', '(m)', 'g');
+              tmp := regexp_replace(tmp, '(\u00D1|\u0143|\u0145|\u0147|\u014A|\u019D|\u01F8|\u0220|\u0274|\u1D0E|\u1E44|\u1E46|\u1E48|\u1E4A|\u24C3|\uFF2E)', 'N', 'g');
+              tmp := regexp_replace(tmp, '(\u00F1|\u0144|\u0146|\u0148|\u0149|\u014B|\u019E|\u01F9|\u0235|\u0272|\u0273|\u1D70|\u1D87|\u1E45|\u1E47|\u1E49|\u1E4B|\u207F|\u24DD|\uFF4E)', 'n', 'g');
+              tmp := regexp_replace(tmp, '(\u01CA)', 'NJ', 'g');
+              tmp := regexp_replace(tmp, '(\u01CB)', 'Nj', 'g');
+              tmp := regexp_replace(tmp, '(\u24A9)', '(n)', 'g');
+              tmp := regexp_replace(tmp, '(\u01CC)', 'nj', 'g');
+              tmp := regexp_replace(tmp, '(\u00D2|\u00D3|\u00D4|\u00D5|\u00D6|\u00D8|\u014C|\u014E|\u0150|\u0186|\u019F|\u01A0|\u01D1|\u01EA|\u01EC|\u01FE|\u020C|\u020E|\u022A|\u022C|\u022E|\u0230|\u1D0F|\u1D10|\u1E4C|\u1E4E|\u1E50|\u1E52|\u1ECC|\u1ECE|\u1ED0|\u1ED2|\u1ED4|\u1ED6|\u1ED8|\u1EDA|\u1EDC|\u1EDE|\u1EE0|\u1EE2|\u24C4|\uA74A|\uA74C|\uFF2F)', 'O', 'g');
+              tmp := regexp_replace(tmp, '(\u00F2|\u00F3|\u00F4|\u00F5|\u00F6|\u00F8|\u014D|\u014F|\u0151|\u01A1|\u01D2|\u01EB|\u01ED|\u01FF|\u020D|\u020F|\u022B|\u022D|\u022F|\u0231|\u0254|\u0275|\u1D16|\u1D17|\u1D97|\u1E4D|\u1E4F|\u1E51|\u1E53|\u1ECD|\u1ECF|\u1ED1|\u1ED3|\u1ED5|\u1ED7|\u1ED9|\u1EDB|\u1EDD|\u1EDF|\u1EE1|\u1EE3|\u2092|\u24DE|\u2C7A|\uA74B|\uA74D|\uFF4F)', 'o', 'g');
+              tmp := regexp_replace(tmp, '(\u0152|\u0276)', 'OE', 'g');
+              tmp := regexp_replace(tmp, '(\uA74E)', 'OO', 'g');
+              tmp := regexp_replace(tmp, '(\u0222|\u1D15)', 'OU', 'g');
+              tmp := regexp_replace(tmp, '(\u24AA)', '(o)', 'g');
+              tmp := regexp_replace(tmp, '(\u0153|\u1D14)', 'oe', 'g');
+              tmp := regexp_replace(tmp, '(\uA74F)', 'oo', 'g');
+              tmp := regexp_replace(tmp, '(\u0223)', 'ou', 'g');
+              tmp := regexp_replace(tmp, '(\u01A4|\u1D18|\u1E54|\u1E56|\u24C5|\u2C63|\uA750|\uA752|\uA754|\uFF30)', 'P', 'g');
+              tmp := regexp_replace(tmp, '(\u01A5|\u1D71|\u1D7D|\u1D88|\u1E55|\u1E57|\u24DF|\uA751|\uA753|\uA755|\uA7FC|\uFF50)', 'p', 'g');
+              tmp := regexp_replace(tmp, '(\u24AB)', '(p)', 'g');
+              tmp := regexp_replace(tmp, '(\u024A|\u24C6|\uA756|\uA758|\uFF31)', 'Q', 'g');
+              tmp := regexp_replace(tmp, '(\u0138|\u024B|\u02A0|\u24E0|\uA757|\uA759|\uFF51)', 'q', 'g');
+              tmp := regexp_replace(tmp, '(\u24AC)', '(q)', 'g');
+              tmp := regexp_replace(tmp, '(\u0239)', 'qp', 'g');
+              tmp := regexp_replace(tmp, '(\u0154|\u0156|\u0158|\u0210|\u0212|\u024C|\u0280|\u0281|\u1D19|\u1D1A|\u1E58|\u1E5A|\u1E5C|\u1E5E|\u24C7|\u2C64|\uA75A|\uA782|\uFF32)', 'R', 'g');
+              tmp := regexp_replace(tmp, '(\u0155|\u0157|\u0159|\u0211|\u0213|\u024D|\u027C|\u027D|\u027E|\u027F|\u1D63|\u1D72|\u1D73|\u1D89|\u1E59|\u1E5B|\u1E5D|\u1E5F|\u24E1|\uA75B|\uA783|\uFF52)', 'r', 'g');
+              tmp := regexp_replace(tmp, '(\u24AD)', '(r)', 'g');
+              tmp := regexp_replace(tmp, '(\u015A|\u015C|\u015E|\u0160|\u0218|\u1E60|\u1E62|\u1E64|\u1E66|\u1E68|\u24C8|\uA731|\uA785|\uFF33)', 'S', 'g');
+              tmp := regexp_replace(tmp, '(\u015B|\u015D|\u015F|\u0161|\u017F|\u0219|\u023F|\u0282|\u1D74|\u1D8A|\u1E61|\u1E63|\u1E65|\u1E67|\u1E69|\u1E9C|\u1E9D|\u24E2|\uA784|\uFF53)', 's', 'g');
+              tmp := regexp_replace(tmp, '(\u1E9E)', 'SS', 'g');
+              tmp := regexp_replace(tmp, '(\u24AE)', '(s)', 'g');
+              tmp := regexp_replace(tmp, '(\u00DF)', 'ss', 'g');
+              tmp := regexp_replace(tmp, '(\uFB06)', 'st', 'g');
+              tmp := regexp_replace(tmp, '(\u0162|\u0164|\u0166|\u01AC|\u01AE|\u021A|\u023E|\u1D1B|\u1E6A|\u1E6C|\u1E6E|\u1E70|\u24C9|\uA786|\uFF34)', 'T', 'g');
+              tmp := regexp_replace(tmp, '(\u0163|\u0165|\u0167|\u01AB|\u01AD|\u021B|\u0236|\u0287|\u0288|\u1D75|\u1E6B|\u1E6D|\u1E6F|\u1E71|\u1E97|\u24E3|\u2C66|\uFF54)', 't', 'g');
+              tmp := regexp_replace(tmp, '(\u00DE|\uA766)', 'TH', 'g');
+              tmp := regexp_replace(tmp, '(\uA728)', 'TZ', 'g');
+              tmp := regexp_replace(tmp, '(\u24AF)', '(t)', 'g');
+              tmp := regexp_replace(tmp, '(\u02A8)', 'tc', 'g');
+              tmp := regexp_replace(tmp, '(\u00FE|\u1D7A|\uA767)', 'th', 'g');
+              tmp := regexp_replace(tmp, '(\u02A6)', 'ts', 'g');
+              tmp := regexp_replace(tmp, '(\uA729)', 'tz', 'g');
+              tmp := regexp_replace(tmp, '(\u00D9|\u00DA|\u00DB|\u00DC|\u0168|\u016A|\u016C|\u016E|\u0170|\u0172|\u01AF|\u01D3|\u01D5|\u01D7|\u01D9|\u01DB|\u0214|\u0216|\u0244|\u1D1C|\u1D7E|\u1E72|\u1E74|\u1E76|\u1E78|\u1E7A|\u1EE4|\u1EE6|\u1EE8|\u1EEA|\u1EEC|\u1EEE|\u1EF0|\u24CA|\uFF35)', 'U', 'g');
+              tmp := regexp_replace(tmp, '(\u00F9|\u00FA|\u00FB|\u00FC|\u0169|\u016B|\u016D|\u016F|\u0171|\u0173|\u01B0|\u01D4|\u01D6|\u01D8|\u01DA|\u01DC|\u0215|\u0217|\u0289|\u1D64|\u1D99|\u1E73|\u1E75|\u1E77|\u1E79|\u1E7B|\u1EE5|\u1EE7|\u1EE9|\u1EEB|\u1EED|\u1EEF|\u1EF1|\u24E4|\uFF55)', 'u', 'g');
+              tmp := regexp_replace(tmp, '(\u24B0)', '(u)', 'g');
+              tmp := regexp_replace(tmp, '(\u1D6B)', 'ue', 'g');
+              tmp := regexp_replace(tmp, '(\u01B2|\u0245|\u1D20|\u1E7C|\u1E7E|\u1EFC|\u24CB|\uA75E|\uA768|\uFF36)', 'V', 'g');
+              tmp := regexp_replace(tmp, '(\u028B|\u028C|\u1D65|\u1D8C|\u1E7D|\u1E7F|\u24E5|\u2C71|\u2C74|\uA75F|\uFF56)', 'v', 'g');
+              tmp := regexp_replace(tmp, '(\uA760)', 'VY', 'g');
+              tmp := regexp_replace(tmp, '(\u24B1)', '(v)', 'g');
+              tmp := regexp_replace(tmp, '(\uA761)', 'vy', 'g');
+              tmp := regexp_replace(tmp, '(\u0174|\u01F7|\u1D21|\u1E80|\u1E82|\u1E84|\u1E86|\u1E88|\u24CC|\u2C72|\uFF37)', 'W', 'g');
+              tmp := regexp_replace(tmp, '(\u0175|\u01BF|\u028D|\u1E81|\u1E83|\u1E85|\u1E87|\u1E89|\u1E98|\u24E6|\u2C73|\uFF57)', 'w', 'g');
+              tmp := regexp_replace(tmp, '(\u24B2)', '(w)', 'g');
+              tmp := regexp_replace(tmp, '(\u1E8A|\u1E8C|\u24CD|\uFF38)', 'X', 'g');
+              tmp := regexp_replace(tmp, '(\u1D8D|\u1E8B|\u1E8D|\u2093|\u24E7|\uFF58)', 'x', 'g');
+              tmp := regexp_replace(tmp, '(\u24B3)', '(x)', 'g');
+              tmp := regexp_replace(tmp, '(\u00DD|\u0176|\u0178|\u01B3|\u0232|\u024E|\u028F|\u1E8E|\u1EF2|\u1EF4|\u1EF6|\u1EF8|\u1EFE|\u24CE|\uFF39)', 'Y', 'g');
+              tmp := regexp_replace(tmp, '(\u00FD|\u00FF|\u0177|\u01B4|\u0233|\u024F|\u028E|\u1E8F|\u1E99|\u1EF3|\u1EF5|\u1EF7|\u1EF9|\u1EFF|\u24E8|\uFF59)', 'y', 'g');
+              tmp := regexp_replace(tmp, '(\u24B4)', '(y)', 'g');
+              tmp := regexp_replace(tmp, '(\u0179|\u017B|\u017D|\u01B5|\u021C|\u0224|\u1D22|\u1E90|\u1E92|\u1E94|\u24CF|\u2C6B|\uA762|\uFF3A)', 'Z', 'g');
+              tmp := regexp_replace(tmp, '(\u017A|\u017C|\u017E|\u01B6|\u021D|\u0225|\u0240|\u0290|\u0291|\u1D76|\u1D8E|\u1E91|\u1E93|\u1E95|\u24E9|\u2C6C|\uA763|\uFF5A)', 'z', 'g');
+              tmp := regexp_replace(tmp, '(\u24B5)', '(z)', 'g');
+              tmp := regexp_replace(tmp, '(\u2070|\u2080|\u24EA|\u24FF|\uFF10)', '0', 'g');
+              tmp := regexp_replace(tmp, '(\u00B9|\u2081|\u2460|\u24F5|\u2776|\u2780|\u278A|\uFF11)', '1', 'g');
+              tmp := regexp_replace(tmp, '(\u2488)', '1.', 'g');
+              tmp := regexp_replace(tmp, '(\u2474)', '(1)', 'g');
+              tmp := regexp_replace(tmp, '(\u00B2|\u2082|\u2461|\u24F6|\u2777|\u2781|\u278B|\uFF12)', '2', 'g');
+              tmp := regexp_replace(tmp, '(\u2489)', '2.', 'g');
+              tmp := regexp_replace(tmp, '(\u2475)', '(2)', 'g');
+              tmp := regexp_replace(tmp, '(\u00B3|\u2083|\u2462|\u24F7|\u2778|\u2782|\u278C|\uFF13)', '3', 'g');
+              tmp := regexp_replace(tmp, '(\u248A)', '3.', 'g');
+              tmp := regexp_replace(tmp, '(\u2476)', '(3)', 'g');
+              tmp := regexp_replace(tmp, '(\u2074|\u2084|\u2463|\u24F8|\u2779|\u2783|\u278D|\uFF14)', '4', 'g');
+              tmp := regexp_replace(tmp, '(\u248B)', '4.', 'g');
+              tmp := regexp_replace(tmp, '(\u2477)', '(4)', 'g');
+              tmp := regexp_replace(tmp, '(\u2075|\u2085|\u2464|\u24F9|\u277A|\u2784|\u278E|\uFF15)', '5', 'g');
+              tmp := regexp_replace(tmp, '(\u248C)', '5.', 'g');
+              tmp := regexp_replace(tmp, '(\u2478)', '(5)', 'g');
+              tmp := regexp_replace(tmp, '(\u2076|\u2086|\u2465|\u24FA|\u277B|\u2785|\u278F|\uFF16)', '6', 'g');
+              tmp := regexp_replace(tmp, '(\u248D)', '6.', 'g');
+              tmp := regexp_replace(tmp, '(\u2479)', '(6)', 'g');
+              tmp := regexp_replace(tmp, '(\u2077|\u2087|\u2466|\u24FB|\u277C|\u2786|\u2790|\uFF17)', '7', 'g');
+              tmp := regexp_replace(tmp, '(\u248E)', '7.', 'g');
+              tmp := regexp_replace(tmp, '(\u247A)', '(7)', 'g');
+              tmp := regexp_replace(tmp, '(\u2078|\u2088|\u2467|\u24FC|\u277D|\u2787|\u2791|\uFF18)', '8', 'g');
+              tmp := regexp_replace(tmp, '(\u248F)', '8.', 'g');
+              tmp := regexp_replace(tmp, '(\u247B)', '(8)', 'g');
+              tmp := regexp_replace(tmp, '(\u2079|\u2089|\u2468|\u24FD|\u277E|\u2788|\u2792|\uFF19)', '9', 'g');
+              tmp := regexp_replace(tmp, '(\u2490)', '9.', 'g');
+              tmp := regexp_replace(tmp, '(\u247C)', '(9)', 'g');
+              tmp := regexp_replace(tmp, '(\u2469|\u24FE|\u277F|\u2789|\u2793)', '10', 'g');
+              tmp := regexp_replace(tmp, '(\u2491)', '10.', 'g');
+              tmp := regexp_replace(tmp, '(\u247D)', '(10)', 'g');
+              tmp := regexp_replace(tmp, '(\u246A|\u24EB)', '11', 'g');
+              tmp := regexp_replace(tmp, '(\u2492)', '11.', 'g');
+              tmp := regexp_replace(tmp, '(\u247E)', '(11)', 'g');
+              tmp := regexp_replace(tmp, '(\u246B|\u24EC)', '12', 'g');
+              tmp := regexp_replace(tmp, '(\u2493)', '12.', 'g');
+              tmp := regexp_replace(tmp, '(\u247F)', '(12)', 'g');
+              tmp := regexp_replace(tmp, '(\u246C|\u24ED)', '13', 'g');
+              tmp := regexp_replace(tmp, '(\u2494)', '13.', 'g');
+              tmp := regexp_replace(tmp, '(\u2480)', '(13)', 'g');
+              tmp := regexp_replace(tmp, '(\u246D|\u24ED)', '14', 'g');
+              tmp := regexp_replace(tmp, '(\u2495)', '14.', 'g');
+              tmp := regexp_replace(tmp, '(\u2481)', '(14)', 'g');
+              tmp := regexp_replace(tmp, '(\u246E|\u24EF)', '15', 'g');
+              tmp := regexp_replace(tmp, '(\u2496)', '15.', 'g');
+              tmp := regexp_replace(tmp, '(\u2482)', '(15)', 'g');
+              tmp := regexp_replace(tmp, '(\u246F|\u24F0)', '16', 'g');
+              tmp := regexp_replace(tmp, '(\u2497)', '16.', 'g');
+              tmp := regexp_replace(tmp, '(\u2483)', '(16)', 'g');
+              tmp := regexp_replace(tmp, '(\u2470|\u24F1)', '17', 'g');
+              tmp := regexp_replace(tmp, '(\u2498)', '17.', 'g');
+              tmp := regexp_replace(tmp, '(\u2484)', '(17)', 'g');
+              tmp := regexp_replace(tmp, '(\u2471|\u24F2)', '18', 'g');
+              tmp := regexp_replace(tmp, '(\u2499)', '18.', 'g');
+              tmp := regexp_replace(tmp, '(\u2485)', '(18)', 'g');
+              tmp := regexp_replace(tmp, '(\u2472|\u24F3)', '19', 'g');
+              tmp := regexp_replace(tmp, '(\u249A)', '19.', 'g');
+              tmp := regexp_replace(tmp, '(\u2486)', '(19)', 'g');
+              tmp := regexp_replace(tmp, '(\u2473|\u24F4)', '20', 'g');
+              tmp := regexp_replace(tmp, '(\u249B)', '20.', 'g');
+              tmp := regexp_replace(tmp, '(\u2487)', '(20)', 'g');
+              tmp := regexp_replace(tmp, '(\u00AB|\u00BB|\u201C|\u201D|\u201E|\u2033|\u2036|\u275D|\u275E|\u276E|\u276F|\uFF02)', '"', 'g');
+              tmp := regexp_replace(tmp, '(\u2018|\u2019|\u201A|\u201B|\u2032|\u2035|\u2039|\u203A|\u275B|\u275C|\uFF07)', '''', 'g');
+              tmp := regexp_replace(tmp, '(\u2010|\u2011|\u2012|\u2013|\u2014|\u207B|\u208B|\uFF0D)', '-', 'g');
+              tmp := regexp_replace(tmp, '(\u2045|\u2772|\uFF3B)', '[', 'g');
+              tmp := regexp_replace(tmp, '(\u2046|\u2773|\uFF3D)', ']', 'g');
+              tmp := regexp_replace(tmp, '(\u207D|\u208D|\u2768|\u276A|\uFF08)', '(', 'g');
+              tmp := regexp_replace(tmp, '(\u2E28)', '((', 'g');
+              tmp := regexp_replace(tmp, '(\u207E|\u208E|\u2769|\u276B|\uFF09)', ')', 'g');
+              tmp := regexp_replace(tmp, '(\u2E29)', '))', 'g');
+              tmp := regexp_replace(tmp, '(\u276C|\u2770|\uFF1C)', '<', 'g');
+              tmp := regexp_replace(tmp, '(\u276D|\u2771|\uFF1E)', '>', 'g');
+              tmp := regexp_replace(tmp, '(\u2774|\uFF5B)', '{', 'g');
+              tmp := regexp_replace(tmp, '(\u2775|\uFF5D)', '}', 'g');
+              tmp := regexp_replace(tmp, '(\u207A|\u208A|\uFF0B)', '+', 'g');
+              tmp := regexp_replace(tmp, '(\u207C|\u208C|\uFF1D)', '=', 'g');
+              tmp := regexp_replace(tmp, '(\uFF01)', '!', 'g');
+              tmp := regexp_replace(tmp, '(\u203C)', '!!', 'g');
+              tmp := regexp_replace(tmp, '(\u2049)', '!?', 'g');
+              tmp := regexp_replace(tmp, '(\uFF03)', '#', 'g');
+              tmp := regexp_replace(tmp, '(\uFF04)', '$', 'g');
+              tmp := regexp_replace(tmp, '(\u2052|\uFF05)', '%', 'g');
+              tmp := regexp_replace(tmp, '(\uFF06)', '&', 'g');
+              tmp := regexp_replace(tmp, '(\u204E|\uFF0A)', '*', 'g');
+              tmp := regexp_replace(tmp, '(\uFF0C)', ',', 'g');
+              tmp := regexp_replace(tmp, '(\uFF0E)', '.', 'g');
+              tmp := regexp_replace(tmp, '(\u2044|\uFF0F)', '/', 'g');
+              tmp := regexp_replace(tmp, '(\uFF1A)', ':', 'g');
+              tmp := regexp_replace(tmp, '(\u204F|\uFF1B)', ';', 'g');
+              tmp := regexp_replace(tmp, '(\uFF1F)', '?', 'g');
+              tmp := regexp_replace(tmp, '(\u2047)', '??', 'g');
+              tmp := regexp_replace(tmp, '(\u2048)', '?!', 'g');
+              tmp := regexp_replace(tmp, '(\uFF20)', '@', 'g');
+              tmp := regexp_replace(tmp, '(\uFF3C)', '\\', 'g');
+              tmp := regexp_replace(tmp, '(\u2038|\uFF3E)', '^', 'g');
+              tmp := regexp_replace(tmp, '(\uFF3F)', '_', 'g');
+              tmp := regexp_replace(tmp, '(\u2053|\uFF5E)', '~', 'g');
+              RETURN tmp;
+            END IF;
+          END
+        $func$
+        RETURNS NULL ON NULL INPUT
+        IMMUTABLE
+        LANGUAGE plpgsql;
+
+        CREATE OR REPLACE FUNCTION concept_label_change_trigger()
+        RETURNS TRIGGER AS
+        $conceptlabelchange$
+           BEGIN
+             IF (TG_OP = 'DELETE') THEN
+              -- update modified date of concept for the hasUnreleasedChanges filter
+              UPDATE concept
+              SET modified = now()
+              WHERE key = OLD.concept_key;
+
+              RETURN OLD;
+            ELSE
+              -- update modified date of concept for the hasUnreleasedChanges filter
+              UPDATE concept
+              SET modified = now()
+              WHERE key = NEW.concept_key;
+
+              NEW.normalized_value := ascii_normalizer(normalize_label(COALESCE(NEW.value,'')));
+              NEW.fulltext_search := TO_TSVECTOR('english_nostop', unaccent(COALESCE(NEW.value,'')));
+              RETURN NEW;
+            END IF;
+           END;
+        $conceptlabelchange$
+        LANGUAGE plpgsql;
+
+        CREATE OR REPLACE FUNCTION normalize_name(name text)
+        RETURNS text AS
+        $func$
+          BEGIN
+            RETURN lower(regexp_replace(name, '(_|-|\s)', '', 'g'));
+          END
+        $func$
+        RETURNS NULL ON NULL INPUT
+        IMMUTABLE
+        LANGUAGE plpgsql;
+
+        CREATE OR REPLACE FUNCTION normalize_label(label text)
+        RETURNS text AS
+        $func$
+          BEGIN
+            RETURN lower(regexp_replace(label, '(\s)', '', 'g'));
+          END
+        $func$
+        RETURNS NULL ON NULL INPUT
+        IMMUTABLE
+        LANGUAGE plpgsql;
+
+        CREATE INDEX concept_normalized_name_idx ON concept(normalize_name(name));
+      ]]>
+    </sql>
+  </changeSet>
+</databaseChangeLog>
diff --git a/core/src/main/resources/liquibase/schema.sql b/core/src/main/resources/liquibase/schema.sql
index d930cce8..84e9588d 100644
--- a/core/src/main/resources/liquibase/schema.sql
+++ b/core/src/main/resources/liquibase/schema.sql
@@ -66,21 +66,21 @@ $func$
   END
 $func$ LANGUAGE plpgsql;
 
-CREATE OR REPLACE FUNCTION normalize_name(name text)
-  RETURNS text AS
-$func$
-  BEGIN
-    RETURN lower(regexp_replace(name, '(_|-|\s)', '', 'g'));
-  END
-$func$ LANGUAGE plpgsql;
+  CREATE OR REPLACE FUNCTION normalize_name(name text)
+    RETURNS text AS
+  $func$
+    BEGIN
+      RETURN lower(regexp_replace(name, '(_|-|\s)', '', 'g'));
+    END
+  $func$ LANGUAGE plpgsql;
 
-CREATE OR REPLACE FUNCTION normalize_label(label text)
-  RETURNS text AS
-$func$
-  BEGIN
-    RETURN lower(regexp_replace(label, '(\s)', '', 'g'));
-  END
-$func$ LANGUAGE plpgsql;
+  CREATE OR REPLACE FUNCTION normalize_label(label text)
+    RETURNS text AS
+  $func$
+    BEGIN
+      RETURN lower(regexp_replace(label, '(\s)', '', 'g'));
+    END
+  $func$ LANGUAGE plpgsql;
 
 CREATE TABLE vocabulary(
   key bigserial NOT NULL PRIMARY KEY,
@@ -216,4 +216,4 @@ LANGUAGE plpgsql;
 
 CREATE TRIGGER concept_fulltext_update
   BEFORE INSERT OR UPDATE ON concept
-  FOR EACH ROW EXECUTE PROCEDURE concept_change_trigger();
\ No newline at end of file
+  FOR EACH ROW EXECUTE PROCEDURE concept_change_trigger();
diff --git a/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/ConceptMapper.xml b/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/ConceptMapper.xml
index 0eaf0fa1..2c0aaf54 100644
--- a/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/ConceptMapper.xml
+++ b/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/ConceptMapper.xml
@@ -553,10 +553,21 @@
   </select>
 
   <!-- TAGS -->
-  <select id="listTags" resultMap="org.gbif.vocabulary.persistence.mappers.TagMapper.TAG_MAP">
+  <sql id="LIST_TAGS">
     SELECT
     <include refid="org.gbif.vocabulary.persistence.mappers.TagMapper.TAG_READ_FIELDS"/>
-    FROM tag t INNER JOIN concept_tag ct ON ct.tag_key = t.key WHERE ct.concept_key = #{key,jdbcType=BIGINT}
+    FROM tag${table_suffix} t INNER JOIN concept_tag${table_suffix} ct ON ct.tag_key = t.key
+    WHERE ct.concept_key = #{key,jdbcType=BIGINT}
+  </sql>
+
+  <select id="listTags" resultMap="org.gbif.vocabulary.persistence.mappers.TagMapper.TAG_MAP">
+    <bind name="table_suffix" value="''"/>
+    <include refid="LIST_TAGS"/>
+  </select>
+
+  <select id="listTagsLatestRelease" resultMap="org.gbif.vocabulary.persistence.mappers.TagMapper.TAG_MAP">
+    <bind name="table_suffix" value="'_' + _parameter.vocabName + '_latest_release_mv'"/>
+    <include refid="LIST_TAGS"/>
   </select>
 
   <insert id="addTag">
@@ -709,46 +720,64 @@
   <!-- latest release views -->
   <select id="existsReleaseView" resultType="java.lang.Boolean">
     SELECT EXISTS (SELECT FROM pg_matviews WHERE matviewname = 'concept_${vocabName}_latest_release_mv')
+      AND EXISTS (SELECT FROM pg_matviews WHERE matviewname = 'tag_${vocabName}_latest_release_mv')
   </select>
 
   <insert id="createLatestReleaseView">
-    CREATE MATERIALIZED VIEW concept_${vocabName}_latest_release_mv AS
+    CREATE MATERIALIZED VIEW IF NOT EXISTS concept_${vocabName}_latest_release_mv AS
     SELECT *
     FROM concept c
     WHERE c.vocabulary_key = ${vocabKey};
 
-    CREATE INDEX c_${vocabName}_latest_release_mv_fulltext_idx
+    CREATE INDEX IF NOT EXISTS c_${vocabName}_latest_release_mv_fulltext_idx
       ON concept_${vocabName}_latest_release_mv USING gin(fulltext_search);
     CREATE UNIQUE INDEX IF NOT EXISTS c_${vocabName}_latest_release_mv_unique
       ON concept_${vocabName}_latest_release_mv(name);
 
-    CREATE MATERIALIZED VIEW concept_label_${vocabName}_latest_release_mv AS
+    CREATE MATERIALIZED VIEW IF NOT EXISTS concept_label_${vocabName}_latest_release_mv AS
     SELECT * FROM concept_label c WHERE c.concept_key IN (SELECT c2.key FROM concept c2 WHERE c2.vocabulary_key = ${vocabKey});
-    CREATE INDEX cl_${vocabName}_latest_release_mv_fulltext_search_idx
+    CREATE INDEX IF NOT EXISTS cl_${vocabName}_latest_release_mv_fulltext_search_idx
       ON concept_label_${vocabName}_latest_release_mv USING gin(fulltext_search);
     CREATE UNIQUE INDEX IF NOT EXISTS cl_${vocabName}_release_mv_unique
       ON concept_label_${vocabName}_latest_release_mv(concept_key, language);
 
-    CREATE MATERIALIZED VIEW concept_alternative_label_${vocabName}_latest_release_mv AS
+    CREATE MATERIALIZED VIEW IF NOT EXISTS concept_alternative_label_${vocabName}_latest_release_mv AS
     SELECT * FROM concept_alternative_label c WHERE c.concept_key IN (SELECT c2.key FROM concept c2 WHERE c2.vocabulary_key = ${vocabKey});
-    CREATE INDEX cal_${vocabName}_latest_release_mv_fulltext_search_idx
+    CREATE INDEX IF NOT EXISTS cal_${vocabName}_latest_release_mv_fulltext_search_idx
       ON concept_alternative_label_${vocabName}_latest_release_mv USING gin(fulltext_search);
     CREATE UNIQUE INDEX IF NOT EXISTS cal_${vocabName}_release_mv_unique
       ON concept_alternative_label_${vocabName}_latest_release_mv(concept_key, language, value);
 
-    CREATE MATERIALIZED VIEW concept_hidden_label_${vocabName}_latest_release_mv AS
+    CREATE MATERIALIZED VIEW IF NOT EXISTS concept_hidden_label_${vocabName}_latest_release_mv AS
     SELECT * FROM concept_hidden_label c WHERE c.concept_key IN (SELECT c2.key FROM concept c2 WHERE c2.vocabulary_key = ${vocabKey});
-    CREATE INDEX chl_${vocabName}_latest_release_mv_fulltext_search_idx
+    CREATE INDEX IF NOT EXISTS chl_${vocabName}_latest_release_mv_fulltext_search_idx
       ON concept_hidden_label_${vocabName}_latest_release_mv USING gin(fulltext_search);
     CREATE UNIQUE INDEX IF NOT EXISTS chl_${vocabName}_release_mv_unique
       ON concept_hidden_label_${vocabName}_latest_release_mv(concept_key, value);
 
-    CREATE MATERIALIZED VIEW concept_definition_${vocabName}_latest_release_mv AS
+    CREATE MATERIALIZED VIEW IF NOT EXISTS concept_definition_${vocabName}_latest_release_mv AS
     SELECT * FROM concept_definition c WHERE c.concept_key IN (SELECT c2.key FROM concept c2 WHERE c2.vocabulary_key = ${vocabKey});
-    CREATE INDEX cd_${vocabName}_latest_release_mv_fulltext_search_idx
+    CREATE INDEX IF NOT EXISTS cd_${vocabName}_latest_release_mv_fulltext_search_idx
       ON concept_definition_${vocabName}_latest_release_mv USING gin(fulltext_search);
     CREATE UNIQUE INDEX IF NOT EXISTS cd_${vocabName}_release_mv_unique
       ON concept_definition_${vocabName}_latest_release_mv(concept_key, language);
+
+    CREATE MATERIALIZED VIEW IF NOT EXISTS tag_${vocabName}_latest_release_mv AS
+    SELECT DISTINCT ON (t.key) t.*
+    FROM tag t
+    INNER JOIN concept_tag ct ON ct.tag_key = t.key
+    INNER JOIN concept c ON c.key = ct.concept_key
+    WHERE c.vocabulary_key = ${vocabKey};
+    CREATE UNIQUE INDEX IF NOT EXISTS tag_${vocabName}_release_mv_unique
+    ON tag_${vocabName}_latest_release_mv(name);
+
+    CREATE MATERIALIZED VIEW IF NOT EXISTS concept_tag_${vocabName}_latest_release_mv AS
+    SELECT ct.*
+    FROM concept_tag ct
+    INNER JOIN concept c ON c.key = ct.concept_key
+    WHERE c.vocabulary_key = ${vocabKey};
+    CREATE UNIQUE INDEX IF NOT EXISTS ct_${vocabName}_release_mv_unique
+    ON concept_tag_${vocabName}_latest_release_mv(concept_key, tag_key);
   </insert>
 
   <update id="updateReleaseViews">
@@ -757,6 +786,8 @@
     REFRESH MATERIALIZED VIEW CONCURRENTLY concept_alternative_label_${vocabName}_latest_release_mv;
     REFRESH MATERIALIZED VIEW CONCURRENTLY concept_hidden_label_${vocabName}_latest_release_mv;
     REFRESH MATERIALIZED VIEW CONCURRENTLY concept_definition_${vocabName}_latest_release_mv;
+    REFRESH MATERIALIZED VIEW CONCURRENTLY tag_${vocabName}_latest_release_mv;
+    REFRESH MATERIALIZED VIEW CONCURRENTLY concept_tag_${vocabName}_latest_release_mv;
   </update>
 
   <select id="listLatestRelease" resultType="Concept" resultMap="CONCEPT_MAP_RELEASE_VIEW">
@@ -857,6 +888,7 @@
     <result property="editorialNotes" column="editorial_notes" typeHandler="StringArrayTypeHandler"/>
     <collection property="definition" column="{entityKey=key,vocabName=vocabName}" select="listConceptDefinitionsLatestRelease"/>
     <collection property="label" column="{entityKey=key,vocabName=vocabName}" select="listConceptLabelsLatestRelease"/>
+    <collection property="tags" column="{key=key,vocabName=vocabName}" select="listTagsLatestRelease"/>
   </resultMap>
 
   <resultMap id="SUGGEST_RESULT_MAP_RELEASE_VIEW" type="SuggestDto" autoMapping="true">
@@ -865,5 +897,49 @@
                 select="findParentsLabelsLatestRelease"/>
   </resultMap>
 
+  <!-- lookup -->
+  <resultMap id="LOOKUP_RESULT_MAP" type="LookupDto" autoMapping="true">
+    <id property="key" column="key"/>
+    <result property="labelLang" column="label_lang" typeHandler="LanguageRegionTypeHandler"/>
+    <result property="altLabelLang" column="alt_label_lang" typeHandler="LanguageRegionTypeHandler"/>
+  </resultMap>
+
+  <select id="lookup" resultMap="LOOKUP_RESULT_MAP">
+    <bind name="table_suffix" value="''"/>
+    <include refid="LOOKUP_COMMON"/>
+  </select>
+
+  <select id="lookupLatestRelease" resultMap="LOOKUP_RESULT_MAP">
+    <bind name="table_suffix" value="'_' + _parameter.vocabName + '_latest_release_mv'"/>
+    <include refid="LOOKUP_COMMON"/>
+  </select>
+
+  <sql id="LOOKUP_COMMON">
+    SELECT DISTINCT ON (key) matches.*
+    FROM (
+      SELECT c.key, c.name, null AS label, null AS label_lang, null AS alt_label, null AS alt_label_lang, null AS hidden_label
+      FROM concept${table_suffix} c
+      WHERE c.vocabulary_key = #{vocabularyKey} AND c.deprecated IS NULL
+      AND normalize_name(c.name) = normalize_name(#{value,jdbcType=VARCHAR})
+    UNION ALL
+      SELECT c.key, c.name, cl.value  AS label, cl."language" AS label_lang, null AS alt_label, null AS alt_label_lang, null AS hidden_label
+      FROM concept${table_suffix} c
+      INNER JOIN concept_label${table_suffix} cl ON cl.concept_key = c.key
+      WHERE c.vocabulary_key = #{vocabularyKey} AND c.deprecated IS NULL
+      AND cl.normalized_value = normalize_label(#{value,jdbcType=VARCHAR})
+    UNION ALL
+      SELECT c.key, c.name, null AS label, null AS label_lang, cal.value AS alt_label, cal."language" AS alt_label_lang, null AS hidden_label
+      FROM concept${table_suffix} c
+      INNER JOIN concept_alternative_label${table_suffix} cal ON cal.concept_key = c.key
+      WHERE c.vocabulary_key = #{vocabularyKey} AND c.deprecated IS NULL
+      AND cal.normalized_value = normalize_label(#{value,jdbcType=VARCHAR})
+    UNION ALL
+      SELECT c.key, c.name, null AS label, null AS label_lang, null AS alt_label, null AS alt_label_lang, chl.value AS hidden_label
+      FROM concept${table_suffix} c
+      INNER JOIN concept_hidden_label${table_suffix} chl ON chl.concept_key = c.key
+      WHERE c.vocabulary_key = #{vocabularyKey} AND c.deprecated IS NULL
+      AND chl.normalized_value = normalize_label(#{value,jdbcType=VARCHAR})
+    ) AS matches
+  </sql>
 
 </mapper>
diff --git a/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/VocabularyMapper.xml b/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/VocabularyMapper.xml
index e03e91f2..f28d6630 100644
--- a/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/VocabularyMapper.xml
+++ b/core/src/main/resources/org/gbif/vocabulary/persistence/mappers/VocabularyMapper.xml
@@ -96,7 +96,7 @@
     WHERE v.name = #{name,jdbcType=VARCHAR}
   </select>
 
-  <select id="getKeyByName" resultMap="VOCABULARY_MAP">
+  <select id="getKeyByName" resultType="java.lang.Long">
     SELECT v.key
     FROM vocabulary v
     WHERE v.name = #{name,jdbcType=VARCHAR}
diff --git a/core/src/test/java/org/gbif/vocabulary/service/ConceptServiceIT.java b/core/src/test/java/org/gbif/vocabulary/service/ConceptServiceIT.java
index a6ec2f5e..73717bd9 100644
--- a/core/src/test/java/org/gbif/vocabulary/service/ConceptServiceIT.java
+++ b/core/src/test/java/org/gbif/vocabulary/service/ConceptServiceIT.java
@@ -13,6 +13,27 @@
  */
 package org.gbif.vocabulary.service;
 
+import static org.gbif.vocabulary.TestUtils.DEFAULT_PAGE;
+import static org.gbif.vocabulary.TestUtils.DEPRECATED_BY;
+import static org.gbif.vocabulary.TestUtils.assertDeprecated;
+import static org.gbif.vocabulary.TestUtils.assertDeprecatedWithReplacement;
+import static org.gbif.vocabulary.TestUtils.assertNotDeprecated;
+import static org.gbif.vocabulary.TestUtils.createBasicConcept;
+import static org.gbif.vocabulary.TestUtils.createBasicVocabulary;
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import javax.sql.DataSource;
 import org.gbif.api.model.common.paging.PagingRequest;
 import org.gbif.api.model.common.paging.PagingResponse;
 import org.gbif.vocabulary.PostgresDBExtension;
@@ -25,17 +46,9 @@
 import org.gbif.vocabulary.model.UserRoles;
 import org.gbif.vocabulary.model.Vocabulary;
 import org.gbif.vocabulary.model.search.ConceptSearchParams;
+import org.gbif.vocabulary.model.search.LookupResult;
 import org.gbif.vocabulary.model.search.SuggestResult;
 import org.gbif.vocabulary.persistence.mappers.VocabularyMapper;
-
-import java.sql.Connection;
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
-import javax.sql.DataSource;
-
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -53,21 +66,6 @@
 import org.springframework.test.context.ContextConfiguration;
 import org.springframework.test.context.junit.jupiter.SpringExtension;
 
-import static org.gbif.vocabulary.TestUtils.DEFAULT_PAGE;
-import static org.gbif.vocabulary.TestUtils.DEPRECATED_BY;
-import static org.gbif.vocabulary.TestUtils.assertDeprecated;
-import static org.gbif.vocabulary.TestUtils.assertDeprecatedWithReplacement;
-import static org.gbif.vocabulary.TestUtils.assertNotDeprecated;
-import static org.gbif.vocabulary.TestUtils.createBasicConcept;
-import static org.gbif.vocabulary.TestUtils.createBasicVocabulary;
-import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertNull;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 /** Integration tests for the {@link ConceptService}. */
 @WithMockUser(authorities = UserRoles.VOCABULARY_ADMIN)
 @ExtendWith(SpringExtension.class)
@@ -960,6 +958,106 @@ public void suggestTest() {
             });
   }
 
+  @Test
+  public void lookupTest() {
+    Concept c1 = createBasicConcept(vocabularies[0].getKey());
+    conceptService.create(c1);
+    Concept c2 = createBasicConcept(vocabularies[0].getKey());
+    conceptService.create(c2);
+
+    List<LookupResult> results =
+        conceptService.lookup(c1.getName().toUpperCase(), vocabularies[0].getName(), null);
+    assertEquals(1, results.size());
+    assertEquals(c1.getName(), results.get(0).getConceptName());
+    assertNull(results.get(0).getMatchedLabel());
+    assertNull(results.get(0).getMatchedLabelLanguage());
+    assertNull(results.get(0).getMatchedAlternativeLabel());
+    assertNull(results.get(0).getMatchedAlternativeLabelLanguage());
+    assertNull(results.get(0).getMatchedHiddenLabel());
+
+    assertTrue(
+        conceptService.lookup("", vocabularies[0].getName(), LanguageRegion.ACHOLI).isEmpty());
+
+    results =
+        conceptService.lookup(
+            c1.getName().toUpperCase(), vocabularies[0].getName(), LanguageRegion.ACHOLI);
+    assertEquals(1, results.size());
+    assertEquals(c1.getName(), results.get(0).getConceptName());
+
+    conceptService.addLabel(
+        c1.getKey(),
+        Label.builder()
+            .value("concept1")
+            .language(LanguageRegion.ENGLISH)
+            .createdBy("test")
+            .build());
+    results = conceptService.lookup("Concept1", vocabularies[0].getName(), null);
+    assertEquals(1, results.size());
+    assertEquals(c1.getName(), results.get(0).getConceptName());
+    assertEquals("concept1", results.get(0).getMatchedLabel());
+    assertEquals(LanguageRegion.ENGLISH, results.get(0).getMatchedLabelLanguage());
+    assertNull(results.get(0).getMatchedAlternativeLabel());
+    assertNull(results.get(0).getMatchedAlternativeLabelLanguage());
+    assertNull(results.get(0).getMatchedHiddenLabel());
+
+    conceptService.addAlternativeLabel(
+        c2.getKey(),
+        Label.builder()
+            .value("alternative 2")
+            .language(LanguageRegion.ENGLISH)
+            .createdBy("test")
+            .build());
+    results = conceptService.lookup("ALternátive2", vocabularies[0].getName(), null);
+    assertEquals(1, results.size());
+    assertEquals(c2.getName(), results.get(0).getConceptName());
+    assertNull(results.get(0).getMatchedLabel());
+    assertNull(results.get(0).getMatchedLabelLanguage());
+    assertEquals("alternative 2", results.get(0).getMatchedAlternativeLabel());
+    assertEquals(LanguageRegion.ENGLISH, results.get(0).getMatchedAlternativeLabelLanguage());
+    assertNull(results.get(0).getMatchedHiddenLabel());
+
+    conceptService.addHiddenLabel(
+        c1.getKey(), HiddenLabel.builder().value("first").createdBy("test").build());
+    results = conceptService.lookup("first", vocabularies[0].getName(), null);
+    assertEquals(1, results.size());
+    assertEquals(c1.getName(), results.get(0).getConceptName());
+    assertNull(results.get(0).getMatchedLabel());
+    assertNull(results.get(0).getMatchedLabelLanguage());
+    assertNull(results.get(0).getMatchedAlternativeLabel());
+    assertNull(results.get(0).getMatchedAlternativeLabelLanguage());
+    assertEquals("first", results.get(0).getMatchedHiddenLabel());
+
+    conceptService.addLabel(
+        c2.getKey(),
+        Label.builder()
+            .value("concept1")
+            .language(LanguageRegion.SPANISH)
+            .createdBy("test")
+            .build());
+    results = conceptService.lookup("Concept1", vocabularies[0].getName(), null);
+    assertEquals(2, results.size());
+
+    results = conceptService.lookup("Concept1", vocabularies[0].getName(), LanguageRegion.SPANISH);
+    assertEquals(1, results.size());
+    assertEquals(c2.getName(), results.get(0).getConceptName());
+    assertEquals("concept1", results.get(0).getMatchedLabel());
+    assertEquals(LanguageRegion.SPANISH, results.get(0).getMatchedLabelLanguage());
+
+    results = conceptService.lookup("Concept1", vocabularies[0].getName(), LanguageRegion.ENGLISH);
+    assertEquals(1, results.size());
+    assertEquals(c1.getName(), results.get(0).getConceptName());
+    assertEquals("concept1", results.get(0).getMatchedLabel());
+    assertEquals(LanguageRegion.ENGLISH, results.get(0).getMatchedLabelLanguage());
+
+    // fallback to English
+    results =
+        conceptService.lookup("Concept1", vocabularies[0].getName(), LanguageRegion.PORTUGUESE);
+    assertEquals(1, results.size());
+    assertEquals(c1.getName(), results.get(0).getConceptName());
+    assertEquals("concept1", results.get(0).getMatchedLabel());
+    assertEquals(LanguageRegion.ENGLISH, results.get(0).getMatchedLabelLanguage());
+  }
+
   static class ContexInitializer
       implements ApplicationContextInitializer<ConfigurableApplicationContext> {
     public void initialize(ConfigurableApplicationContext configurableApplicationContext) {
diff --git a/core/src/test/java/org/gbif/vocabulary/service/ExportServiceTest.java b/core/src/test/java/org/gbif/vocabulary/service/ExportServiceTest.java
index 8c25d69c..698982f1 100644
--- a/core/src/test/java/org/gbif/vocabulary/service/ExportServiceTest.java
+++ b/core/src/test/java/org/gbif/vocabulary/service/ExportServiceTest.java
@@ -13,6 +13,22 @@
  */
 package org.gbif.vocabulary.service;
 
+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;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.when;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import java.io.IOException;
+import java.nio.file.Path;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
 import org.gbif.api.model.common.paging.PagingRequest;
 import org.gbif.api.model.common.paging.PagingResponse;
 import org.gbif.vocabulary.model.Concept;
@@ -20,36 +36,18 @@
 import org.gbif.vocabulary.model.HiddenLabel;
 import org.gbif.vocabulary.model.Label;
 import org.gbif.vocabulary.model.LanguageRegion;
+import org.gbif.vocabulary.model.Tag;
 import org.gbif.vocabulary.model.UserRoles;
 import org.gbif.vocabulary.model.Vocabulary;
 import org.gbif.vocabulary.model.export.Export;
 import org.gbif.vocabulary.model.export.VocabularyExportView;
 import org.gbif.vocabulary.persistence.mappers.VocabularyReleaseMapper;
-
-import java.io.IOException;
-import java.nio.file.Path;
-import java.time.LocalDateTime;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.mock.mockito.MockBean;
 import org.springframework.security.access.AccessDeniedException;
 import org.springframework.security.test.context.support.WithMockUser;
 
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-
-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;
-import static org.mockito.Mockito.any;
-import static org.mockito.Mockito.when;
-
 /** Tests the {@link ExportService}. */
 public class ExportServiceTest extends MockServiceBaseTest {
 
@@ -88,6 +86,15 @@ public void exportVocabularyTest() throws IOException {
     assertEquals(export.getVocabularyExport().getVocabulary().getName(), vocabularyName);
     assertEquals(3, export.getConceptExports().size());
     assertNotNull(export.getMetadata().getCreatedDate());
+
+    export
+        .getConceptExports()
+        .forEach(
+            c -> {
+              if (c.getConcept().getName().equals("c1")) {
+                assertEquals(2, c.getTags().size());
+              }
+            });
   }
 
   private void mockVocabulary(String vocabularyName) {
@@ -101,6 +108,14 @@ private void mockVocabulary(String vocabularyName) {
     c1.setVocabularyKey(vocabulary.getKey());
     c1.setCreated(LocalDateTime.now());
 
+    // tags
+    Tag tag1 = new Tag();
+    tag1.setName("tag1");
+    c1.getTags().add(tag1);
+    Tag tag2 = new Tag();
+    tag2.setName("tag2");
+    c1.getTags().add(tag2);
+
     // labels
     List<Label> c1Labels = new ArrayList<>();
     c1Labels.add(Label.builder().language(LanguageRegion.ENGLISH).value("Label").build());
diff --git a/core/src/test/resources/application-test.yml b/core/src/test/resources/application-test.yml
index 4bb17b61..d3c9f164 100644
--- a/core/src/test/resources/application-test.yml
+++ b/core/src/test/resources/application-test.yml
@@ -5,3 +5,6 @@ spring:
 logging:
   level:
     liquibase: warn
+
+ws:
+  apiUrl: https://test.com
diff --git a/model/src/main/java/org/gbif/vocabulary/model/export/ConceptExportView.java b/model/src/main/java/org/gbif/vocabulary/model/export/ConceptExportView.java
index fdb6e10e..b858e38f 100644
--- a/model/src/main/java/org/gbif/vocabulary/model/export/ConceptExportView.java
+++ b/model/src/main/java/org/gbif/vocabulary/model/export/ConceptExportView.java
@@ -34,4 +34,5 @@ public class ConceptExportView {
   private Map<LanguageRegion, String> label = new EnumMap<>(LanguageRegion.class);
   private Map<LanguageRegion, Set<String>> alternativeLabels = new EnumMap<>(LanguageRegion.class);
   private Set<String> hiddenLabels = new HashSet<>();
+  private Set<String> tags = new HashSet<>();
 }
diff --git a/model/src/main/java/org/gbif/vocabulary/model/search/LookupResult.java b/model/src/main/java/org/gbif/vocabulary/model/search/LookupResult.java
new file mode 100644
index 00000000..7a9b8b6e
--- /dev/null
+++ b/model/src/main/java/org/gbif/vocabulary/model/search/LookupResult.java
@@ -0,0 +1,16 @@
+package org.gbif.vocabulary.model.search;
+
+import lombok.Data;
+import org.gbif.vocabulary.model.LanguageRegion;
+
+@Data
+public class LookupResult {
+
+  private String conceptName;
+  private String conceptLink;
+  private String matchedLabel;
+  private LanguageRegion matchedLabelLanguage;
+  private String matchedAlternativeLabel;
+  private LanguageRegion matchedAlternativeLabelLanguage;
+  private String matchedHiddenLabel;
+}
diff --git a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/utils/Constants.java b/model/src/main/java/org/gbif/vocabulary/model/utils/PathUtils.java
similarity index 94%
rename from vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/utils/Constants.java
rename to model/src/main/java/org/gbif/vocabulary/model/utils/PathUtils.java
index ab52d730..d11fe2bd 100644
--- a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/utils/Constants.java
+++ b/model/src/main/java/org/gbif/vocabulary/model/utils/PathUtils.java
@@ -11,13 +11,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.gbif.vocabulary.restws.utils;
+package org.gbif.vocabulary.model.utils;
 
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 
 @NoArgsConstructor(access = AccessLevel.PRIVATE)
-public class Constants {
+public class PathUtils {
   public static final String VOCABULARIES_PATH = "vocabularies";
   public static final String CONCEPTS_PATH = "concepts";
   public static final String VOCABULARY_LANGUAGE_PATH = "vocabularyLanguage";
diff --git a/pom.xml b/pom.xml
index 32a11d21..8f835784 100644
--- a/pom.xml
+++ b/pom.xml
@@ -75,7 +75,7 @@
     <gbif-common-ws.version>1.21</gbif-common-ws.version>
 
     <!-- DB -->
-    <postgresql-testcontainers.version>1.16.0</postgresql-testcontainers.version>
+    <postgresql-testcontainers.version>1.19.8</postgresql-testcontainers.version>
     <mybatis.spring.boot.starter>2.1.0</mybatis.spring.boot.starter>
     <postgresql.version>42.2.23</postgresql.version>
 
diff --git a/vocabulary-importer/README.md b/vocabulary-importer/README.md
index bcc7c026..c756fd13 100644
--- a/vocabulary-importer/README.md
+++ b/vocabulary-importer/README.md
@@ -125,7 +125,7 @@ This tool can be run via command line by sending these params:
     columns are required so, for example, it can be used to import only definitions. When this option is used the vocabulary
     label and definition are not required.
 
-Example of a migration:
+Example of an import:
 
 ```
 java -jar vocabulary-importer/target/vocabulary-importer-1.0.3.jar \
diff --git a/vocabulary-importer/src/main/java/org/gbif/vocabulary/importer/VocabularyImporter.java b/vocabulary-importer/src/main/java/org/gbif/vocabulary/importer/VocabularyImporter.java
index b95d34ff..4594a232 100644
--- a/vocabulary-importer/src/main/java/org/gbif/vocabulary/importer/VocabularyImporter.java
+++ b/vocabulary-importer/src/main/java/org/gbif/vocabulary/importer/VocabularyImporter.java
@@ -13,22 +13,22 @@
  */
 package org.gbif.vocabulary.importer;
 
-import org.gbif.api.model.common.paging.PagingRequest;
-import org.gbif.api.model.common.paging.PagingResponse;
-import org.gbif.vocabulary.api.AddTagAction;
-import org.gbif.vocabulary.api.ConceptListParams;
-import org.gbif.vocabulary.api.ConceptView;
-import org.gbif.vocabulary.client.ConceptClient;
-import org.gbif.vocabulary.client.TagClient;
-import org.gbif.vocabulary.client.VocabularyClient;
-import org.gbif.vocabulary.model.Concept;
-import org.gbif.vocabulary.model.Definition;
-import org.gbif.vocabulary.model.HiddenLabel;
-import org.gbif.vocabulary.model.Label;
-import org.gbif.vocabulary.model.LanguageRegion;
-import org.gbif.vocabulary.model.Tag;
-import org.gbif.vocabulary.model.Vocabulary;
+import static org.gbif.vocabulary.importer.Fields.ALT_LABELS_PREFIX;
+import static org.gbif.vocabulary.importer.Fields.CONCEPT;
+import static org.gbif.vocabulary.importer.Fields.CONCEPT_FIELDS;
+import static org.gbif.vocabulary.importer.Fields.DEFINITION_PREFIX;
+import static org.gbif.vocabulary.importer.Fields.EXTERNAL_DEFINITIONS;
+import static org.gbif.vocabulary.importer.Fields.LABEL_PREFIX;
+import static org.gbif.vocabulary.importer.Fields.PARENT;
+import static org.gbif.vocabulary.importer.Fields.SAME_AS_URIS;
+import static org.gbif.vocabulary.importer.Fields.TAGS;
 
+import com.google.common.base.Preconditions;
+import com.google.common.base.Strings;
+import com.opencsv.CSVParser;
+import com.opencsv.CSVParserBuilder;
+import com.opencsv.CSVReader;
+import com.opencsv.CSVReaderBuilder;
 import java.io.BufferedWriter;
 import java.io.IOException;
 import java.net.URI;
@@ -49,27 +49,24 @@
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
-
-import com.google.common.base.Preconditions;
-import com.google.common.base.Strings;
-import com.opencsv.CSVParser;
-import com.opencsv.CSVParserBuilder;
-import com.opencsv.CSVReader;
-import com.opencsv.CSVReaderBuilder;
-
 import lombok.AllArgsConstructor;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-
-import static org.gbif.vocabulary.importer.Fields.ALT_LABELS_PREFIX;
-import static org.gbif.vocabulary.importer.Fields.CONCEPT;
-import static org.gbif.vocabulary.importer.Fields.CONCEPT_FIELDS;
-import static org.gbif.vocabulary.importer.Fields.DEFINITION_PREFIX;
-import static org.gbif.vocabulary.importer.Fields.EXTERNAL_DEFINITIONS;
-import static org.gbif.vocabulary.importer.Fields.LABEL_PREFIX;
-import static org.gbif.vocabulary.importer.Fields.PARENT;
-import static org.gbif.vocabulary.importer.Fields.SAME_AS_URIS;
-import static org.gbif.vocabulary.importer.Fields.TAGS;
+import org.gbif.api.model.common.paging.PagingRequest;
+import org.gbif.api.model.common.paging.PagingResponse;
+import org.gbif.vocabulary.api.AddTagAction;
+import org.gbif.vocabulary.api.ConceptListParams;
+import org.gbif.vocabulary.api.ConceptView;
+import org.gbif.vocabulary.client.ConceptClient;
+import org.gbif.vocabulary.client.TagClient;
+import org.gbif.vocabulary.client.VocabularyClient;
+import org.gbif.vocabulary.model.Concept;
+import org.gbif.vocabulary.model.Definition;
+import org.gbif.vocabulary.model.HiddenLabel;
+import org.gbif.vocabulary.model.Label;
+import org.gbif.vocabulary.model.LanguageRegion;
+import org.gbif.vocabulary.model.Tag;
+import org.gbif.vocabulary.model.Vocabulary;
 
 @Slf4j
 public class VocabularyImporter {
@@ -405,10 +402,11 @@ private Concept migrateConcept(
                 addTag(
                     vocabularyName, c.getName(), t, targetConceptClient, targetTagClient, errors));
 
-    PagingRequest page = new PagingRequest(0, 100);
+    long offset = 0;
+    int limit = 100;
     PagingResponse<Label> alternativeLables =
         conceptClient.listAlternativeLabels(
-            vocabularyName, c.getName(), ConceptClient.ListParams.of(null, page));
+            vocabularyName, c.getName(), ConceptClient.ListParams.of(null, offset, limit));
     while (!alternativeLables.getResults().isEmpty()) {
       alternativeLables
           .getResults()
@@ -417,20 +415,17 @@ private Concept migrateConcept(
                   addAlternativeLabel(
                       vocabularyName, c.getName(), al, targetConceptClient, errors));
 
+      offset += limit;
       alternativeLables =
           conceptClient.listAlternativeLabels(
-              vocabularyName,
-              c.getName(),
-              ConceptClient.ListParams.of(
-                  null,
-                  new PagingRequest(
-                      alternativeLables.getOffset() + alternativeLables.getLimit(),
-                      alternativeLables.getLimit())));
+              vocabularyName, c.getName(), ConceptClient.ListParams.of(null, offset, limit));
     }
 
-    page = new PagingRequest(0, 100);
+    offset = 0;
+    limit = 100;
     PagingResponse<HiddenLabel> hiddenLabels =
-        conceptClient.listHiddenLabels(vocabularyName, c.getName(), page);
+        conceptClient.listHiddenLabels(
+            vocabularyName, c.getName(), new PagingRequest(offset, limit));
     while (!hiddenLabels.getResults().isEmpty()) {
       hiddenLabels
           .getResults()
@@ -439,12 +434,10 @@ private Concept migrateConcept(
                   addHiddenLabel(
                       vocabularyName, errors, c.getName(), hl.getValue(), c, targetConceptClient));
 
+      offset += limit;
       hiddenLabels =
           conceptClient.listHiddenLabels(
-              vocabularyName,
-              c.getName(),
-              new PagingRequest(
-                  hiddenLabels.getOffset() + hiddenLabels.getLimit(), hiddenLabels.getLimit()));
+              vocabularyName, c.getName(), new PagingRequest(offset, limit));
     }
 
     return created.getConcept();
diff --git a/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/InMemoryVocabularyLookup.java b/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/InMemoryVocabularyLookup.java
index 577541a0..76eb73f5 100644
--- a/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/InMemoryVocabularyLookup.java
+++ b/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/InMemoryVocabularyLookup.java
@@ -13,12 +13,13 @@
  */
 package org.gbif.vocabulary.lookup;
 
-import org.gbif.vocabulary.model.Concept;
-import org.gbif.vocabulary.model.LanguageRegion;
-import org.gbif.vocabulary.model.export.ConceptExportView;
-import org.gbif.vocabulary.model.export.Export;
-import org.gbif.vocabulary.tools.VocabularyDownloader;
+import static org.gbif.vocabulary.model.normalizers.StringNormalizer.normalizeLabel;
+import static org.gbif.vocabulary.model.normalizers.StringNormalizer.normalizeName;
+import static org.gbif.vocabulary.model.normalizers.StringNormalizer.replaceNonAsciiCharactersWithEquivalents;
 
+import com.fasterxml.jackson.databind.DeserializationFeature;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
 import java.io.InputStream;
 import java.util.ArrayList;
 import java.util.Collections;
@@ -31,20 +32,14 @@
 import java.util.Set;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
-
-import org.cache2k.Cache;
-import org.cache2k.Cache2kBuilder;
-
-import com.fasterxml.jackson.databind.DeserializationFeature;
-import com.fasterxml.jackson.databind.ObjectMapper;
-import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
-
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
-
-import static org.gbif.vocabulary.model.normalizers.StringNormalizer.normalizeLabel;
-import static org.gbif.vocabulary.model.normalizers.StringNormalizer.normalizeName;
-import static org.gbif.vocabulary.model.normalizers.StringNormalizer.replaceNonAsciiCharactersWithEquivalents;
+import org.cache2k.Cache;
+import org.cache2k.Cache2kBuilder;
+import org.gbif.vocabulary.model.LanguageRegion;
+import org.gbif.vocabulary.model.export.ConceptExportView;
+import org.gbif.vocabulary.model.export.Export;
+import org.gbif.vocabulary.tools.VocabularyDownloader;
 
 /**
  * Class that allows to load a vocabulary export in memory to do fast lookups by concept labels.
@@ -93,17 +88,17 @@ public class InMemoryVocabularyLookup implements VocabularyLookup {
           .registerModule(new JavaTimeModule())
           .disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
 
-  private final Cache<String, Concept> namesCache;
+  private final Cache<String, ConceptExportView> namesCache;
   private final Cache<String, LabelMatch> labelsCache;
-  private final Cache<String, Concept> hiddenLabelsCache;
-  private final Cache<Long, Concept> conceptsByKeyCache;
+  private final Cache<String, ConceptExportView> hiddenLabelsCache;
+  private final Cache<Long, ConceptExportView> conceptsByKeyCache;
   private final Function<String, String> prefilter;
 
   private InMemoryVocabularyLookup(InputStream in, Function<String, String> prefilter) {
     Objects.requireNonNull(in);
     this.prefilter = prefilter;
     namesCache =
-        Cache2kBuilder.of(String.class, Concept.class)
+        Cache2kBuilder.of(String.class, ConceptExportView.class)
             .eternal(true)
             .entryCapacity(Long.MAX_VALUE)
             .build();
@@ -112,12 +107,12 @@ private InMemoryVocabularyLookup(InputStream in, Function<String, String> prefil
             .entryCapacity(Long.MAX_VALUE)
             .build();
     hiddenLabelsCache =
-        Cache2kBuilder.of(String.class, Concept.class)
+        Cache2kBuilder.of(String.class, ConceptExportView.class)
             .eternal(true)
             .entryCapacity(Long.MAX_VALUE)
             .build();
     conceptsByKeyCache =
-        Cache2kBuilder.of(Long.class, Concept.class)
+        Cache2kBuilder.of(Long.class, ConceptExportView.class)
             .eternal(true)
             .entryCapacity(Long.MAX_VALUE)
             .build();
@@ -169,9 +164,10 @@ public Optional<LookupConcept> lookup(String value, LanguageRegion contextLang)
       String transformedValue = t.apply(normalizedValue);
 
       // matching by name
-      Concept nameMatch = namesCache.get(transformedValue);
+      ConceptExportView nameMatch = namesCache.get(transformedValue);
       if (nameMatch != null) {
-        log.debug("value {} matched with concept {} by name", value, nameMatch.getName());
+        log.debug(
+            "value {} matched with concept {} by name", value, nameMatch.getConcept().getName());
         return Optional.of(toLookupConcept(nameMatch));
       }
 
@@ -179,19 +175,22 @@ public Optional<LookupConcept> lookup(String value, LanguageRegion contextLang)
       LabelMatch labelMatch = labelsCache.get(transformedValue);
       if (labelMatch != null) {
         if (labelMatch.allMatches.size() == 1) {
-          Concept conceptMatched = labelMatch.allMatches.iterator().next();
-          log.debug("value {} matched with concept {} by label", value, conceptMatched.getName());
+          ConceptExportView conceptMatched = labelMatch.allMatches.iterator().next();
+          log.debug(
+              "value {} matched with concept {} by label",
+              value,
+              conceptMatched.getConcept().getName());
           return Optional.of(toLookupConcept(conceptMatched));
         }
 
         // several candidates found. We try to match by using the language received as discriminator
         // or English as fallback
-        Optional<Concept> langMatch = matchByLanguage(labelMatch, contextLang, value);
+        Optional<ConceptExportView> langMatch = matchByLanguage(labelMatch, contextLang, value);
         if (langMatch.isPresent()) {
           log.debug(
               "value {} matched with concept {} by language {}",
               value,
-              langMatch.get().getName(),
+              langMatch.get().getConcept().getName(),
               contextLang);
           return Optional.of(toLookupConcept(langMatch.get()));
         }
@@ -203,9 +202,12 @@ public Optional<LookupConcept> lookup(String value, LanguageRegion contextLang)
       }
 
       // if no match we try with the hidden labels
-      Concept hiddenMatch = hiddenLabelsCache.get(transformedValue);
+      ConceptExportView hiddenMatch = hiddenLabelsCache.get(transformedValue);
       if (hiddenMatch != null) {
-        log.debug("value {} matched with concept {} by hidden label", value, hiddenMatch);
+        log.debug(
+            "value {} matched with concept {} by hidden label",
+            value,
+            hiddenMatch.getConcept().getName());
         return Optional.of(toLookupConcept(hiddenMatch));
       }
     }
@@ -214,8 +216,9 @@ public Optional<LookupConcept> lookup(String value, LanguageRegion contextLang)
     return Optional.empty();
   }
 
-  private Optional<Concept> matchByLanguage(LabelMatch match, LanguageRegion lang, String value) {
-    Set<Concept> langMatches = null;
+  private Optional<ConceptExportView> matchByLanguage(
+      LabelMatch match, LanguageRegion lang, String value) {
+    Set<ConceptExportView> langMatches = null;
     if (lang != null) {
       langMatches = match.matchesByLanguage.get(lang);
     }
@@ -231,7 +234,7 @@ private Optional<Concept> matchByLanguage(LabelMatch match, LanguageRegion lang,
     }
 
     if (langMatches.size() == 1) {
-      Concept conceptMatched = langMatches.iterator().next();
+      ConceptExportView conceptMatched = langMatches.iterator().next();
       log.debug(
           "Value {} matched with concept {} by using language {}", value, conceptMatched, lang);
       return Optional.of(conceptMatched);
@@ -262,32 +265,28 @@ private void importVocabulary(InputStream in) {
 
     for (ConceptExportView conceptExport : export.getConceptExports()) {
       // add to the cache concepts
-      conceptsByKeyCache.put(conceptExport.getConcept().getKey(), conceptExport.getConcept());
+      conceptsByKeyCache.put(conceptExport.getConcept().getKey(), conceptExport);
 
       // add name to the cache
-      addNameToCache(conceptExport.getConcept());
+      addNameToCache(conceptExport);
 
       // add labels to the cache
-      conceptExport
-          .getLabel()
-          .forEach((key, value) -> addLabelToCache(value, conceptExport.getConcept(), key));
+      conceptExport.getLabel().forEach((key, value) -> addLabelToCache(value, conceptExport, key));
 
       // add alternative labels to the cache
       conceptExport
           .getAlternativeLabels()
-          .forEach((key, value) -> addLabelsToCache(value, conceptExport.getConcept(), key));
+          .forEach((key, value) -> addLabelsToCache(value, conceptExport, key));
 
       // add hidden labels to the cache
-      conceptExport
-          .getHiddenLabels()
-          .forEach(label -> addHiddenLabelToCache(label, conceptExport.getConcept()));
+      conceptExport.getHiddenLabels().forEach(label -> addHiddenLabelToCache(label, conceptExport));
     }
   }
 
-  private void addNameToCache(Concept concept) {
+  private void addNameToCache(ConceptExportView concept) {
     String normalizedValue =
-        replaceNonAsciiCharactersWithEquivalents(normalizeName(concept.getName()));
-    Concept existing = namesCache.peekAndPut(normalizedValue, concept);
+        replaceNonAsciiCharactersWithEquivalents(normalizeName(concept.getConcept().getName()));
+    ConceptExportView existing = namesCache.peekAndPut(normalizedValue, concept);
 
     if (existing != null) {
       log.warn(
@@ -297,11 +296,12 @@ private void addNameToCache(Concept concept) {
     }
   }
 
-  private void addLabelsToCache(Set<String> values, Concept concept, LanguageRegion language) {
+  private void addLabelsToCache(
+      Set<String> values, ConceptExportView concept, LanguageRegion language) {
     values.forEach(v -> addLabelToCache(v, concept, language));
   }
 
-  private void addLabelToCache(String value, Concept concept, LanguageRegion language) {
+  private void addLabelToCache(String value, ConceptExportView concept, LanguageRegion language) {
     if (prefilter != null) {
       value = prefilter.apply(value);
     }
@@ -330,15 +330,16 @@ private void addLabelToCache(String value, Concept concept, LanguageRegion langu
     }
   }
 
-  private void addHiddenLabelToCache(String hiddenLabel, Concept concept) {
+  private void addHiddenLabelToCache(String hiddenLabel, ConceptExportView concept) {
     if (prefilter != null) {
       hiddenLabel = prefilter.apply(hiddenLabel);
     }
 
     String normalizedValue = replaceNonAsciiCharactersWithEquivalents(normalizeLabel(hiddenLabel));
-    Concept existing = hiddenLabelsCache.peekAndPut(normalizedValue, concept);
+    ConceptExportView existing = hiddenLabelsCache.peekAndPut(normalizedValue, concept);
 
-    if (existing != null && !existing.getName().equals(concept.getName())) {
+    if (existing != null
+        && !existing.getConcept().getName().equals(concept.getConcept().getName())) {
       log.warn(
           "Incorrect vocabulary: different concepts cannot have the same hidden label. "
               + "The concept hidden label: {} in the concept: {} is also present in: {}",
@@ -348,28 +349,35 @@ private void addHiddenLabelToCache(String hiddenLabel, Concept concept) {
     }
   }
 
-  private LookupConcept toLookupConcept(Concept concept) {
+  private LookupConcept toLookupConcept(ConceptExportView conceptExportView) {
     // find parents
-    List<String> parents = new ArrayList<>();
-    Long parentKey = concept.getParentKey();
+    List<LookupConcept.Parent> parents = new ArrayList<>();
+    Long parentKey = conceptExportView.getConcept().getParentKey();
     while (parentKey != null) {
-      Concept parent = conceptsByKeyCache.get(parentKey);
-      parents.add(parent.getName());
+      ConceptExportView parent = conceptsByKeyCache.get(parentKey);
+
+      if (parent == null) {
+        break;
+      }
+
+      parents.add(LookupConcept.Parent.from(parent));
 
-      if (parentKey.equals(parent.getParentKey())) {
+      if (parentKey.equals(parent.getConcept().getParentKey())) {
         // this should never happen but we protect against it
         break;
       }
 
-      parentKey = parent.getParentKey();
+      parentKey = parent.getConcept().getParentKey();
     }
 
-    return LookupConcept.of(concept, parents);
+    return LookupConcept.of(
+        conceptExportView.getConcept(), parents, new ArrayList<>(conceptExportView.getTags()));
   }
 
   private static class LabelMatch {
-    Set<Concept> allMatches = new HashSet<>();
-    Map<LanguageRegion, Set<Concept>> matchesByLanguage = new EnumMap<>(LanguageRegion.class);
+    Set<ConceptExportView> allMatches = new HashSet<>();
+    Map<LanguageRegion, Set<ConceptExportView>> matchesByLanguage =
+        new EnumMap<>(LanguageRegion.class);
   }
 
   public static InMemoryVocabularyLookupBuilder newBuilder() {
diff --git a/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/LookupConcept.java b/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/LookupConcept.java
index 90363ea7..f2f8ad2b 100644
--- a/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/LookupConcept.java
+++ b/vocabulary-lookup/src/main/java/org/gbif/vocabulary/lookup/LookupConcept.java
@@ -13,17 +13,35 @@
  */
 package org.gbif.vocabulary.lookup;
 
-import org.gbif.vocabulary.model.Concept;
-
+import java.util.ArrayList;
 import java.util.List;
-
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import org.gbif.vocabulary.model.Concept;
+import org.gbif.vocabulary.model.export.ConceptExportView;
 
 @Data
 @AllArgsConstructor(staticName = "of")
 public class LookupConcept {
 
   private Concept concept;
-  private List<String> parents;
+  private List<Parent> parents;
+  private List<String> tags;
+
+  @Data
+  @AllArgsConstructor(staticName = "of")
+  public static class Parent {
+    private Long key;
+    private Long parentKey;
+    private String name;
+    private List<String> tags;
+
+    public static Parent from(ConceptExportView conceptExportView) {
+      return Parent.of(
+          conceptExportView.getConcept().getKey(),
+          conceptExportView.getConcept().getParentKey(),
+          conceptExportView.getConcept().getName(),
+          new ArrayList<>(conceptExportView.getTags()));
+    }
+  }
 }
diff --git a/vocabulary-lookup/src/test/java/org/gbif/vocabulary/lookup/PathwayLookupTest.java b/vocabulary-lookup/src/test/java/org/gbif/vocabulary/lookup/PathwayLookupTest.java
new file mode 100644
index 00000000..319df453
--- /dev/null
+++ b/vocabulary-lookup/src/test/java/org/gbif/vocabulary/lookup/PathwayLookupTest.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.gbif.vocabulary.lookup;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class PathwayLookupTest {
+
+  private static final String PATHWAY_VOCAB_FILE = "Pathway.json";
+  private static final InMemoryVocabularyLookup LOOKUP =
+      InMemoryVocabularyLookup.newBuilder()
+          .from(
+              Thread.currentThread()
+                  .getContextClassLoader()
+                  .getResourceAsStream(PATHWAY_VOCAB_FILE))
+          .build();
+
+  @Test
+  public void adultTest() {
+    LookupConcept lookupConcept = LOOKUP.lookup("natural dispersal").get();
+    assertEquals(2, lookupConcept.getParents().size());
+    assertEquals("unaided", lookupConcept.getParents().get(0).getName());
+    assertEquals("corridorAndDispersal", lookupConcept.getParents().get(1).getName());
+  }
+}
diff --git a/vocabulary-lookup/src/test/java/org/gbif/vocabulary/lookup/VocabularyLookupTest.java b/vocabulary-lookup/src/test/java/org/gbif/vocabulary/lookup/VocabularyLookupTest.java
index 6aeb5e7d..81adcb13 100644
--- a/vocabulary-lookup/src/test/java/org/gbif/vocabulary/lookup/VocabularyLookupTest.java
+++ b/vocabulary-lookup/src/test/java/org/gbif/vocabulary/lookup/VocabularyLookupTest.java
@@ -52,7 +52,7 @@ public void lookupTest() {
     assertTrue(concept.isPresent());
     assertEquals("February", concept.get().getConcept().getName());
     assertEquals(1, concept.get().getParents().size());
-    assertTrue(concept.get().getParents().contains("January"));
+    assertTrue(concept.get().getParents().stream().anyMatch(p -> p.getName().equals("January")));
 
     concept = vocabulary.lookup("Fev");
     assertTrue(concept.isPresent());
@@ -73,7 +73,8 @@ public void lookupTest() {
     concept = vocabulary.lookup("march");
     assertTrue(concept.isPresent());
     assertEquals(2, concept.get().getParents().size());
-    assertEquals(Arrays.asList("February", "January"), concept.get().getParents());
+    assertEquals("February", concept.get().getParents().get(0).getName());
+    assertEquals("January", concept.get().getParents().get(1).getName());
   }
 
   @Test
diff --git a/vocabulary-lookup/src/test/resources/Pathway.json b/vocabulary-lookup/src/test/resources/Pathway.json
new file mode 100644
index 00000000..36c0c694
--- /dev/null
+++ b/vocabulary-lookup/src/test/resources/Pathway.json
@@ -0,0 +1,1299 @@
+{
+  "metadata" : {
+    "createdDate" : "2024-04-29T08:46:25.24",
+    "version" : "1.0.2"
+  },
+  "vocabulary" : {
+    "key" : 5,
+    "name" : "Pathway",
+    "externalDefinitions" : [ "https://dwc.tdwg.org/pw/" ],
+    "editorialNotes" : [ "Created as a faithful port of https://dwc.tdwg.org/pw/ in English only" ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:51.511113",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:48.208379",
+    "modifiedBy" : "mlopezg",
+    "namespace" : null,
+    "definition" : {
+      "en" : "Provides the controlled vocabulary for information about the process by which an Organism came to be in a given place at a given time. the pathway of an organism or organisms have been introduced to a given place and time. The Pathway Controlled Vocabulary provides terms that should be used as values for the Darwin Core terms dwc:pathway and dwciri:pathway."
+    },
+    "label" : {
+      "en" : "Pathway"
+    }
+  },
+  "concepts" : [ {
+    "key" : 115,
+    "name" : "otherTransport",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p041" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:58.575073",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "A catchall term for any transport related dispersal that is not covered in other terms."
+    },
+    "label" : {
+      "en" : "Other means of transport"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 114,
+    "name" : "vehicles",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p040" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:58.480326",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Other vehicle hitchhikers that have been unintentionally dispersed, but are not covered by other terms."
+    },
+    "label" : {
+      "en" : "Vehicles (car, train, etc.)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 113,
+    "name" : "hullFouling",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p039" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:58.397057",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms that attach themselves to the subsurface hull of boats and ships."
+    },
+    "label" : {
+      "en" : "Ship/boat hull fouling"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 112,
+    "name" : "ballastWater",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p038" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:58.297303",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms transported within the water pumped into boats and ships to provide ballast."
+    },
+    "label" : {
+      "en" : "Ship/boat ballast water"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 111,
+    "name" : "packingMaterial",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p037" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:58.210453",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ "deprecated" ],
+    "definition" : {
+      "en" : "Organic material, particularly unprocessed plant material that is used to pack transported goods."
+    },
+    "label" : {
+      "en" : "Organic packing material, in particular wood packaging"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 110,
+    "name" : "people",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p036" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:58.051573",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms transported on people themselves and/or their personal luggage."
+    },
+    "label" : {
+      "en" : "People and their luggage/equipment (in particular tourism)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 109,
+    "name" : "machineryEquipment",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p035" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:57.891841",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms carried on the surfaces of or within heavy machinery and equipment."
+    },
+    "label" : {
+      "en" : "Machinery/equipment"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 108,
+    "name" : "hitchhikersShip",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p034" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:57.781126",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms that enter directly onto boats or ships and are transported by them to another location."
+    },
+    "label" : {
+      "en" : "Hitchhikers on ship/boat (excluding ballast water and hull fouling)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 107,
+    "name" : "hitchhikersAirplane",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p033" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:57.696084",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms that enter airplanes or other aircraft, such as helicopters, and are transported by them to another location."
+    },
+    "label" : {
+      "en" : "Hitchhikers in or on airplane"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 106,
+    "name" : "containerBulk",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p032" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:57.527803",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Stowaways transported in or on the cargo containers or bulk cargo units themselves."
+    },
+    "label" : {
+      "en" : "Container/bulk"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 105,
+    "name" : "fishingEquipment",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p031" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:57.354295",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 69,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Aquatic organisms moved between sites on equipment of recreational anglers and professional fishermen."
+    },
+    "label" : {
+      "en" : "Angling/fishing equipment"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 104,
+    "name" : "transportationHabitatMaterial",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p030" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:57.240398",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms transported with their habitat material to a new location."
+    },
+    "label" : {
+      "en" : "Transportation of habitat material (soil, vegetation, wood etc)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 103,
+    "name" : "timberTrade",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p029" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:57.086833",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Contaminants on unprocessed timber, processed wood and wood derived products."
+    },
+    "label" : {
+      "en" : "Timber trade"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 102,
+    "name" : "seedContaminant",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p028" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:56.929871",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms contaminating transported seeds."
+    },
+    "label" : {
+      "en" : "Seed contaminant"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 101,
+    "name" : "parasitesOnPlants",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p027" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:56.838818",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Parasitic and pathogenic organisms transported with their host or vector plant."
+    },
+    "label" : {
+      "en" : "Parasites on plants (including species transported by host and vector)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 100,
+    "name" : "contaminantOnPlants",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p026" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:56.733953",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms transported on plant material."
+    },
+    "label" : {
+      "en" : "Contaminant on plants (except parasites, species transported by host/vector)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 99,
+    "name" : "parasitesOnAnimals",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p025" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:56.331219",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Parasitic and pathogenic organisms transported with their host or vector animal."
+    },
+    "label" : {
+      "en" : "Parasites on animals (including organisms transported by host and vector)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 98,
+    "name" : "contaminantOnAnimals",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p024" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:56.131244",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Contaminants carried either on or in the body of transported animals."
+    },
+    "label" : {
+      "en" : "Contaminant on animals (except parasites, organisms transported by host/vector)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 97,
+    "name" : "foodContaminant",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p023" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.959508",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Foods for human consumption, whether they are transported life or dead."
+    },
+    "label" : {
+      "en" : "Food contaminant (including of live food)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 96,
+    "name" : "contaminateBait",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p022" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.785216",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Contaminants, pathogens and parasites transported with live, frozen or preserved bait used to catch fish or other organisms."
+    },
+    "label" : {
+      "en" : "Contaminated bait"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 95,
+    "name" : "contaminantNursery",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p021" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.650016",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 68,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms transported into an area together with plant material."
+    },
+    "label" : {
+      "en" : "Contaminant nursery material"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 94,
+    "name" : "otherEscape",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p020" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.515563",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms brought into an area with the intention of keeping them in captivity permanently, but that have subsequently escaped."
+    },
+    "label" : {
+      "en" : "Other escape from confinement"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 93,
+    "name" : "liveFoodLiveBait",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p019" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.421104",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Live food imported for human consumption, such as shellfish and snails, and for live bait."
+    },
+    "label" : {
+      "en" : "Live food and live bait"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 92,
+    "name" : "research",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p018" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.296966",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Plants and animals introduced for the purpose of breeding, scientific and medical research, including science education."
+    },
+    "label" : {
+      "en" : "Research and ex-situ breeding (in facilities)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 91,
+    "name" : "ornamentalNonHorticulture",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p017" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.196474",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Ornamental plants introduced through pathways other than the horticultural industry."
+    },
+    "label" : {
+      "en" : "Ornamental purpose other than horticulture"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 90,
+    "name" : "horticulture",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p016" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.104576",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Plants distributed by the ornamental and decorative plants industry."
+    },
+    "label" : {
+      "en" : "Horticulture"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 89,
+    "name" : "fur",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p015" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:55.005076",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms escaped from a fur farms, including unauthorised releases."
+    },
+    "label" : {
+      "en" : "Fur farms"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 88,
+    "name" : "forestry",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p014" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:54.907456",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Trees specifically introduced to provide timber and other forestry products."
+    },
+    "label" : {
+      "en" : "Forestry (including reforestation)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 87,
+    "name" : "farmedAnimals",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p013" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:54.807434",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Animals cared for and bred with the specific intention of using their products, such as meat and milk."
+    },
+    "label" : {
+      "en" : "Farmed animals (including animals left under limited control)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 86,
+    "name" : "pet",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p012" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:54.710796",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Privately kept animals."
+    },
+    "label" : {
+      "en" : "Pet/aquarium/terrarium species (including live food for such species )"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 85,
+    "name" : "publicGardenZooAquaria",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p011" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:54.526019",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms in public collections of plants and/or animals."
+    },
+    "label" : {
+      "en" : "Botanic garden/zoo/aquaria (excluding domestic aquaria)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 84,
+    "name" : "aquacultureMariculture",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p010" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:54.438344",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "The analog of agriculture and farmed animals, specifically related to aquatic organisms."
+    },
+    "label" : {
+      "en" : "Aquaculture/mariculture"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 83,
+    "name" : "agriculture",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p009" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:54.25909",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 67,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Plants grown with then intention of harvesting."
+    },
+    "label" : {
+      "en" : "Agriculture (including biofuel feedstocks)"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 82,
+    "name" : "otherIntentionalRelease",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p008" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:54.157149",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "A catch-all for intentional releases not for human use that are not covered by other more specific terms."
+    },
+    "label" : {
+      "en" : "Other intentional release"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 81,
+    "name" : "releasedForUse",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p007" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.959082",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Release in nature for use (other than above, e.g., fur, transport, medical use)."
+    },
+    "label" : {
+      "en" : "Released for use"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 80,
+    "name" : "conservationOrWildlifeManagement",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p006" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.80844",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms introduced for conservation purposes or wildlife management."
+    },
+    "label" : {
+      "en" : "Conservation or wildlife management"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 79,
+    "name" : "landscapeImprovement",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p005" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.715247",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Landscape/flora/fauna \"improvement\" in the wild."
+    },
+    "label" : {
+      "en" : "Landscape improvement"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 78,
+    "name" : "hunting",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p004" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.613484",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Animals stocked into the wild specifically with the intention that they would be hunted for sport."
+    },
+    "label" : {
+      "en" : "Hunting"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 77,
+    "name" : "fisheryInTheWild",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p003" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.513466",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Fish stocked into the wild either to create a fishery or for recreational angling."
+    },
+    "label" : {
+      "en" : "Fishery in the wild"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 76,
+    "name" : "erosionControl",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p002" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.383497",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms introduced for the purpose of erosion control/dune stabilization (windbreaks, hedges, etc)."
+    },
+    "label" : {
+      "en" : "Erosion control"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 75,
+    "name" : "biologicalControl",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p001" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.297431",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 66,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms occuring in an area because they were introduced for the purpose of biological control of another organism."
+    },
+    "label" : {
+      "en" : "Biological control"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 74,
+    "name" : "naturalDispersal",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p044" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.206023",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 71,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Dispersal of organisms to new regions by natural dispersal from regions in which they are alien."
+    },
+    "label" : {
+      "en" : "Natural dispersal across borders of invasive alien organisms"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 73,
+    "name" : "tunnelsBridges",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p043" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:53.126204",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 70,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Unintentional dispersal by organisms using artificial tunnels, bridges, roads and railways."
+    },
+    "label" : {
+      "en" : "Tunnels and land bridges"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 72,
+    "name" : "waterwaysBasinsSeas",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p042" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.998119",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 70,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms that dispersed through artificial waterways created to connect previosuly unconnected water bodies."
+    },
+    "label" : {
+      "en" : "Interconnected waterways/basins/seas"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 71,
+    "name" : "unaided",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p050" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.843911",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 65,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms that spread by natural dispersal, without action or assistance by humans, from regions in which they are also alien."
+    },
+    "label" : {
+      "en" : "Unaided"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 70,
+    "name" : "corridor",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p049" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.730755",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 65,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Infrastructure, such as bridges, tunnels and canals have removed natural barriers to dispersal and allowed a species to move into a novel location."
+    },
+    "label" : {
+      "en" : "Corridor"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 69,
+    "name" : "transportStowaway",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p048" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.633689",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 64,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "An umbrella term for all species transported by riding on forms of transport where the organism has a direct interation with the transport and is not merely carried as part of, or a contaminent of cargo."
+    },
+    "label" : {
+      "en" : "Transport-stowaway"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 68,
+    "name" : "transportContaminant",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p047" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.541555",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 64,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "An umbrella term for all species transported as contaninents in other products."
+    },
+    "label" : {
+      "en" : "Transport-contaminant"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 67,
+    "name" : "escapeFromConfinement",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p046" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.388099",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 63,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms intentionally transported by humans and intended to be kept in captivity or cultivation, but having inadvertently escaped from human control."
+    },
+    "label" : {
+      "en" : "Escape from confinement"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 66,
+    "name" : "releaseInNature",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p045" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.277367",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : 63,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms transported and released by humans in a (semi)natural environment with the intention that they should live their without further human aid."
+    },
+    "label" : {
+      "en" : "Release in nature"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 65,
+    "name" : "corridorAndDispersal",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p053" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:52.095841",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : null,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms dispersed naturally, even if that dispersal was aided by changes in the landscape created by humans."
+    },
+    "label" : {
+      "en" : "Corridor and dispersal"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 64,
+    "name" : "unintentional",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p052" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:51.965375",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : null,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "The organism was unintentionally brought to a new region."
+    },
+    "label" : {
+      "en" : "Unintentional"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  }, {
+    "key" : 63,
+    "name" : "intentional",
+    "externalDefinitions" : [ "http://rs.tdwg.org/dwcpw/values/p051" ],
+    "editorialNotes" : [ ],
+    "replacedByKey" : null,
+    "deprecated" : null,
+    "deprecatedBy" : null,
+    "created" : "2021-12-02T11:01:51.807299",
+    "createdBy" : "mlopezg",
+    "modified" : "2023-02-28T10:21:50.204464",
+    "modifiedBy" : "mlopezg",
+    "vocabularyKey" : 5,
+    "parentKey" : null,
+    "sameAsUris" : [ ],
+    "tags" : [ ],
+    "definition" : {
+      "en" : "Organisms were brought to new area with the specific intention of keeping them alive in the new region, regardless of whether they were intended to be cultivated or released into the wild."
+    },
+    "label" : {
+      "en" : "Intentional"
+    },
+    "alternativeLabels" : { },
+    "hiddenLabels" : [ ]
+  } ]
+}
diff --git a/vocabulary-rest-ws-client/src/main/java/org/gbif/vocabulary/client/ConceptClient.java b/vocabulary-rest-ws-client/src/main/java/org/gbif/vocabulary/client/ConceptClient.java
index 1f580b69..8408664b 100644
--- a/vocabulary-rest-ws-client/src/main/java/org/gbif/vocabulary/client/ConceptClient.java
+++ b/vocabulary-rest-ws-client/src/main/java/org/gbif/vocabulary/client/ConceptClient.java
@@ -13,6 +13,8 @@
  */
 package org.gbif.vocabulary.client;
 
+import java.util.List;
+import lombok.AllArgsConstructor;
 import org.gbif.api.model.common.paging.Pageable;
 import org.gbif.api.model.common.paging.PagingRequest;
 import org.gbif.api.model.common.paging.PagingResponse;
@@ -27,9 +29,7 @@
 import org.gbif.vocabulary.model.LanguageRegion;
 import org.gbif.vocabulary.model.Tag;
 import org.gbif.vocabulary.model.search.KeyNameResult;
-
-import java.util.List;
-
+import org.gbif.vocabulary.model.search.LookupResult;
 import org.springframework.cloud.openfeign.SpringQueryMap;
 import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.DeleteMapping;
@@ -41,8 +41,6 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 
-import lombok.AllArgsConstructor;
-
 @RequestMapping("vocabularies/{vocabularyName}/concepts")
 public interface ConceptClient {
 
@@ -105,7 +103,7 @@ default List<Definition> listDefinitions(
       @PathVariable("vocabularyName") String vocabularyName,
       @PathVariable("name") String conceptName,
       List<LanguageRegion> lang) {
-    return listDefinitions(vocabularyName, conceptName, ListParams.of(lang, null));
+    return listDefinitions(vocabularyName, conceptName, ListParams.of(lang, null, null));
   }
 
   @GetMapping(value = "{name}/definition/{key}", produces = MediaType.APPLICATION_JSON_VALUE)
@@ -169,7 +167,7 @@ List<Label> listLabels(
 
   default List<Label> listLabels(
       String vocabularyName, String conceptName, List<LanguageRegion> languageRegion) {
-    return listLabels(vocabularyName, conceptName, ListParams.of(languageRegion, null));
+    return listLabels(vocabularyName, conceptName, ListParams.of(languageRegion, null, null));
   }
 
   @GetMapping(value = "{name}/alternativeLabels", produces = MediaType.APPLICATION_JSON_VALUE)
@@ -180,7 +178,8 @@ PagingResponse<Label> listAlternativeLabels(
 
   default PagingResponse<Label> listAlternativeLabels(
       String vocabularyName, String conceptName, List<LanguageRegion> lang, Pageable page) {
-    return listAlternativeLabels(vocabularyName, conceptName, ListParams.of(lang, page));
+    return listAlternativeLabels(
+        vocabularyName, conceptName, ListParams.of(lang, page.getOffset(), page.getLimit()));
   }
 
   @GetMapping(value = "{name}/hiddenLabels", produces = MediaType.APPLICATION_JSON_VALUE)
@@ -256,7 +255,8 @@ default List<Definition> listDefinitionsFromLatestRelease(
       @PathVariable("vocabularyName") String vocabularyName,
       @PathVariable("name") String conceptName,
       List<LanguageRegion> lang) {
-    return listDefinitionsFromLatestRelease(vocabularyName, conceptName, ListParams.of(lang, null));
+    return listDefinitionsFromLatestRelease(
+        vocabularyName, conceptName, ListParams.of(lang, null, null));
   }
 
   @GetMapping("latestRelease/{name}/label")
@@ -268,7 +268,7 @@ List<Label> listLabelsFromLatestRelease(
   default List<Label> listLabelsFromLatestRelease(
       String vocabularyName, String conceptName, List<LanguageRegion> languageRegion) {
     return listLabelsFromLatestRelease(
-        vocabularyName, conceptName, ListParams.of(languageRegion, null));
+        vocabularyName, conceptName, ListParams.of(languageRegion, null, null));
   }
 
   @GetMapping("latestRelease/{name}/alternativeLabels")
@@ -280,7 +280,7 @@ PagingResponse<Label> listAlternativeLabelsFromLatestRelease(
   default PagingResponse<Label> listAlternativeLabelsFromLatestRelease(
       String vocabularyName, String conceptName, List<LanguageRegion> lang, Pageable page) {
     return listAlternativeLabelsFromLatestRelease(
-        vocabularyName, conceptName, ListParams.of(lang, page));
+        vocabularyName, conceptName, ListParams.of(lang, page.getOffset(), page.getLimit()));
   }
 
   @GetMapping("latestRelease/{name}/hiddenLabels")
@@ -292,7 +292,7 @@ PagingResponse<HiddenLabel> listHiddenLabelsFromLatestRelease(
   default PagingResponse<HiddenLabel> listHiddenLabelsFromLatestRelease(
       String vocabularyName, String conceptName, Pageable page) {
     return listHiddenLabelsFromLatestRelease(
-        vocabularyName, conceptName, ListParams.of(null, page));
+        vocabularyName, conceptName, ListParams.of(null, page.getOffset(), page.getLimit()));
   }
 
   @GetMapping("latestRelease/suggest")
@@ -300,10 +300,23 @@ List<KeyNameResult> suggestLatestRelease(
       @PathVariable("vocabularyName") String vocabularyName,
       @SpringQueryMap SuggestParams suggestParams);
 
+  @GetMapping(value = "lookup", produces = MediaType.APPLICATION_JSON_VALUE)
+  List<LookupResult> lookup(
+      @PathVariable("vocabularyName") String vocabularyName,
+      @RequestParam("q") String q,
+      @SpringQueryMap LookupParams lookupParams);
+
+  @GetMapping(value = "latestRelease/lookup", produces = MediaType.APPLICATION_JSON_VALUE)
+  List<LookupResult> lookupInLatestRelease(
+      @PathVariable("vocabularyName") String vocabularyName,
+      @RequestParam("q") String q,
+      @SpringQueryMap LookupParams lookupParams);
+
   @AllArgsConstructor(staticName = "of")
   class ListParams {
     List<LanguageRegion> lang;
-    Pageable page;
+    Long offset;
+    Integer limit;
   }
 
   @AllArgsConstructor(staticName = "of")
@@ -313,4 +326,9 @@ class SuggestParams {
     String q;
     Integer limit;
   }
+
+  @AllArgsConstructor(staticName = "of")
+  class LookupParams {
+    LanguageRegion lang;
+  }
 }
diff --git a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/ConceptResource.java b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/ConceptResource.java
index fe1d6bbd..5b5ce5cf 100644
--- a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/ConceptResource.java
+++ b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/ConceptResource.java
@@ -13,6 +13,26 @@
  */
 package org.gbif.vocabulary.restws.resources;
 
+import static com.google.common.base.Preconditions.checkArgument;
+import static org.gbif.vocabulary.model.utils.PathUtils.*;
+import static org.gbif.vocabulary.restws.resources.LatestReleaseCache.conceptSuggestLatestReleaseCache;
+
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.Parameters;
+import io.swagger.v3.oas.annotations.enums.Explode;
+import io.swagger.v3.oas.annotations.enums.ParameterIn;
+import io.swagger.v3.oas.annotations.extensions.Extension;
+import io.swagger.v3.oas.annotations.extensions.ExtensionProperty;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.responses.ApiResponse;
+import java.util.*;
+import java.util.function.Function;
+import java.util.function.LongFunction;
+import java.util.function.Supplier;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import org.assertj.core.util.Strings;
 import org.gbif.api.documentation.CommonParameters;
 import org.gbif.api.model.common.paging.Pageable;
 import org.gbif.api.model.common.paging.PagingResponse;
@@ -25,38 +45,16 @@
 import org.gbif.vocabulary.model.exception.EntityNotFoundException.EntityType;
 import org.gbif.vocabulary.model.search.ChildrenResult;
 import org.gbif.vocabulary.model.search.ConceptSearchParams;
+import org.gbif.vocabulary.model.search.LookupResult;
 import org.gbif.vocabulary.model.search.SuggestResult;
 import org.gbif.vocabulary.restws.config.WsConfig;
 import org.gbif.vocabulary.restws.documentation.Docs;
 import org.gbif.vocabulary.service.ConceptService;
 import org.gbif.vocabulary.service.TagService;
 import org.gbif.vocabulary.service.VocabularyService;
-
-import java.util.*;
-import java.util.function.Function;
-import java.util.function.LongFunction;
-import java.util.function.Supplier;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import org.assertj.core.util.Strings;
 import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.*;
 
-import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.Parameter;
-import io.swagger.v3.oas.annotations.Parameters;
-import io.swagger.v3.oas.annotations.enums.Explode;
-import io.swagger.v3.oas.annotations.enums.ParameterIn;
-import io.swagger.v3.oas.annotations.extensions.Extension;
-import io.swagger.v3.oas.annotations.extensions.ExtensionProperty;
-import io.swagger.v3.oas.annotations.media.Schema;
-import io.swagger.v3.oas.annotations.responses.ApiResponse;
-
-import static com.google.common.base.Preconditions.checkArgument;
-import static org.gbif.vocabulary.restws.resources.LatestReleaseCache.conceptSuggestLatestReleaseCache;
-import static org.gbif.vocabulary.restws.utils.Constants.*;
-
 @io.swagger.v3.oas.annotations.tags.Tag(
     name = "Concepts",
     description =
@@ -266,11 +264,6 @@ public ConceptView get(
       @RequestParam(value = "includeParents", required = false) boolean includeParents,
       @RequestParam(value = "includeChildren", required = false) boolean includeChildren) {
     Concept concept = getConceptWithCheck(conceptName, vocabularyName);
-
-    if (concept == null) {
-      return null;
-    }
-
     ConceptView conceptView =
         createConceptView(includeParents, includeChildren, concept, vocabularyName);
 
@@ -1007,6 +1000,69 @@ public PagingResponse<HiddenLabel> listHiddenLabelsFromLatestRelease(
         getConceptWithCheck(conceptName, vocabularyName).getKey(), page, vocabularyName);
   }
 
+  @Operation(
+      operationId = "lookup",
+      summary = "Concept lookup",
+      description = "Lookup a concept given a specific value and an optional language.",
+      extensions =
+          @Extension(
+              name = "Order",
+              properties = @ExtensionProperty(name = "Order", value = "0900")))
+  @Parameters(
+      value = {
+        @Parameter(
+            name = "q",
+            description = "Value to do the lookup against to",
+            schema = @Schema(implementation = String.class),
+            in = ParameterIn.QUERY),
+        @Parameter(
+            name = "lang",
+            description = "Lang to discriminate the lookup",
+            schema = @Schema(implementation = LanguageRegion.class),
+            in = ParameterIn.QUERY)
+      })
+  @Docs.DefaultSearchResponses
+  @GetMapping("lookup")
+  public List<LookupResult> lookup(
+      @PathVariable("vocabularyName") String vocabularyName,
+      @RequestParam("q") String q,
+      LanguageRegion lang) {
+    getVocabularyWithCheck(vocabularyName);
+    return conceptService.lookup(q, vocabularyName, lang);
+  }
+
+  @Operation(
+      operationId = "lookupLatestRelease",
+      summary = "Concept lookup in the latest release",
+      description =
+          "Lookup a concept in the latest release of the vocabulary given a specific value and an optional language.",
+      extensions =
+          @Extension(
+              name = "Order",
+              properties = @ExtensionProperty(name = "Order", value = "0900")))
+  @Parameters(
+      value = {
+        @Parameter(
+            name = "q",
+            description = "Value to do the lookup against to",
+            schema = @Schema(implementation = String.class),
+            in = ParameterIn.QUERY),
+        @Parameter(
+            name = "lang",
+            description = "Lang to discriminate the lookup",
+            schema = @Schema(implementation = LanguageRegion.class),
+            in = ParameterIn.QUERY)
+      })
+  @Docs.DefaultSearchResponses
+  @GetMapping(LATEST_RELEASE_PATH + "/lookup")
+  public List<LookupResult> lookupInLatestRelease(
+      @PathVariable("vocabularyName") String vocabularyName,
+      @RequestParam("q") String q,
+      LanguageRegion lang) {
+    getVocabularyWithCheck(vocabularyName);
+    return conceptService.lookupLatestRelease(q, vocabularyName, lang);
+  }
+
   private ConceptView createConceptView(
       boolean includeParents, boolean includeChildren, Concept concept, String vocabularyName) {
     if (concept == null) {
diff --git a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/TagResource.java b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/TagResource.java
index 24876903..203f9347 100644
--- a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/TagResource.java
+++ b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/TagResource.java
@@ -36,7 +36,7 @@
 import io.swagger.v3.oas.annotations.responses.ApiResponse;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static org.gbif.vocabulary.restws.utils.Constants.TAGS_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.TAGS_PATH;
 
 @io.swagger.v3.oas.annotations.tags.Tag(
     name = "Tags",
diff --git a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyLanguageResource.java b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyLanguageResource.java
index 6746e701..c285705b 100644
--- a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyLanguageResource.java
+++ b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyLanguageResource.java
@@ -15,7 +15,7 @@
 
 import org.gbif.vocabulary.model.LanguageRegion;
 import org.gbif.vocabulary.model.LanguageRegion.LanguageRegionAllFieldsSerializer;
-import org.gbif.vocabulary.restws.utils.Constants;
+import org.gbif.vocabulary.model.utils.PathUtils;
 
 import org.springframework.http.MediaType;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -41,7 +41,7 @@
             name = "Order",
             properties = @ExtensionProperty(name = "Order", value = "0400")))
 @RestController
-@RequestMapping(Constants.VOCABULARY_LANGUAGE_PATH)
+@RequestMapping(PathUtils.VOCABULARY_LANGUAGE_PATH)
 public class VocabularyLanguageResource {
 
   private static final SimpleModule LANGUAGE_SERIALIZER_MODULE =
diff --git a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyResource.java b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyResource.java
index 22d21ced..b60877e8 100644
--- a/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyResource.java
+++ b/vocabulary-rest-ws/src/main/java/org/gbif/vocabulary/restws/resources/VocabularyResource.java
@@ -65,8 +65,8 @@
 import lombok.extern.slf4j.Slf4j;
 
 import static com.google.common.base.Preconditions.checkArgument;
-import static org.gbif.vocabulary.restws.utils.Constants.VOCABULARIES_PATH;
-import static org.gbif.vocabulary.restws.utils.Constants.VOCABULARY_RELEASES_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.VOCABULARIES_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.VOCABULARY_RELEASES_PATH;
 
 /** Controller for {@link org.gbif.vocabulary.model.Vocabulary} entities. */
 @OpenAPIDefinition(
diff --git a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/ConceptResourceIT.java b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/ConceptResourceIT.java
index f3f8f0a5..45bd671c 100644
--- a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/ConceptResourceIT.java
+++ b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/ConceptResourceIT.java
@@ -13,6 +13,19 @@
  */
 package org.gbif.vocabulary.restws.resources;
 
+import static org.gbif.vocabulary.model.utils.PathUtils.CONCEPTS_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.VOCABULARIES_PATH;
+import static org.gbif.vocabulary.restws.TestCredentials.ADMIN;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.UUID;
 import org.gbif.api.model.common.paging.PagingRequest;
 import org.gbif.api.model.common.paging.PagingResponse;
 import org.gbif.vocabulary.api.AddTagAction;
@@ -27,13 +40,6 @@
 import org.gbif.vocabulary.model.Tag;
 import org.gbif.vocabulary.model.Vocabulary;
 import org.gbif.vocabulary.service.ConceptService;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.UUID;
-
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -46,14 +52,6 @@
 import org.springframework.test.web.reactive.server.WebTestClient;
 import org.springframework.web.reactive.function.BodyInserters;
 
-import static org.gbif.vocabulary.restws.TestCredentials.ADMIN;
-import static org.gbif.vocabulary.restws.utils.Constants.CONCEPTS_PATH;
-import static org.gbif.vocabulary.restws.utils.Constants.VOCABULARIES_PATH;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
-import static org.junit.jupiter.api.Assertions.assertTrue;
-
 /** IT for the {@link ConceptResource}. */
 @ContextConfiguration(initializers = {ConceptResourceIT.ContextInitializer.class})
 public class ConceptResourceIT extends BaseResourceIT<Concept> {
@@ -517,6 +515,21 @@ public void releaseViewTest() {
     assertFalse(conceptView.getConcept().getLabel().isEmpty());
   }
 
+  @Test
+  public void lookupTest() {
+    Concept c1 = createEntity();
+    conceptClient.create(defaultVocabularyName, c1);
+
+    assertEquals(
+        1,
+        conceptClient
+            .lookup(
+                defaultVocabularyName,
+                c1.getName().toUpperCase(),
+                ConceptClient.LookupParams.of(null))
+            .size());
+  }
+
   @Override
   Concept createEntity() {
     Concept concept = new Concept();
diff --git a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/VocabularyResourceIT.java b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/VocabularyResourceIT.java
index 7bf1f548..74d4a36a 100644
--- a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/VocabularyResourceIT.java
+++ b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/VocabularyResourceIT.java
@@ -36,7 +36,7 @@
 import org.springframework.context.ConfigurableApplicationContext;
 import org.springframework.test.context.ContextConfiguration;
 
-import static org.gbif.vocabulary.restws.utils.Constants.VOCABULARIES_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.VOCABULARIES_PATH;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
diff --git a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/ConceptResourceTest.java b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/ConceptResourceTest.java
index 26a0965e..2a123ada 100644
--- a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/ConceptResourceTest.java
+++ b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/ConceptResourceTest.java
@@ -44,8 +44,8 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.google.common.collect.ImmutableList;
 
-import static org.gbif.vocabulary.restws.utils.Constants.CONCEPTS_PATH;
-import static org.gbif.vocabulary.restws.utils.Constants.VOCABULARIES_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.CONCEPTS_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.VOCABULARIES_PATH;
 import static org.hamcrest.Matchers.endsWith;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.hasItem;
diff --git a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/VocabularyResourceTest.java b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/VocabularyResourceTest.java
index e14f6417..f378e502 100644
--- a/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/VocabularyResourceTest.java
+++ b/vocabulary-rest-ws/src/test/java/org/gbif/vocabulary/restws/resources/mock/VocabularyResourceTest.java
@@ -43,8 +43,8 @@
 import com.fasterxml.jackson.databind.JsonNode;
 import com.google.common.collect.ImmutableList;
 
-import static org.gbif.vocabulary.restws.utils.Constants.VOCABULARIES_PATH;
-import static org.gbif.vocabulary.restws.utils.Constants.VOCABULARY_RELEASES_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.VOCABULARIES_PATH;
+import static org.gbif.vocabulary.model.utils.PathUtils.VOCABULARY_RELEASES_PATH;
 import static org.hamcrest.Matchers.endsWith;
 import static org.hamcrest.Matchers.equalTo;
 import static org.hamcrest.Matchers.is;