diff --git a/.github/workflows/labels-verify.yml b/.github/workflows/labels-verify.yml
index d3067e48a..3f14112bd 100644
--- a/.github/workflows/labels-verify.yml
+++ b/.github/workflows/labels-verify.yml
@@ -10,4 +10,4 @@ jobs:
     steps:
       - uses: zwaldowski/match-label-action@v2
         with:
-          allowed: 'type:bug, type:enhancement, type:improvement, type:dependencies, type:internal, type:invalid'
+          allowed: 'type:bug, type:new feature, type:improvement, type:dependencies, type:internal, type:invalid'
diff --git a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java
index 53a040a09..6ae21bc43 100644
--- a/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java
+++ b/allure-java-commons-test/src/main/java/io/qameta/allure/test/AllureFeatures.java
@@ -222,4 +222,12 @@
     @Feature("Timeline")
     @interface Severity {
     }
+
+    @Documented
+    @Inherited
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.METHOD, ElementType.TYPE})
+    @Feature("Filtration")
+    @interface Filtration {
+    }
 }
diff --git a/allure-junit-platform/build.gradle.kts b/allure-junit-platform/build.gradle.kts
index 82528cfc2..a4b970826 100644
--- a/allure-junit-platform/build.gradle.kts
+++ b/allure-junit-platform/build.gradle.kts
@@ -7,6 +7,7 @@ dependencies {
     api(project(":allure-java-commons"))
     implementation("org.junit.jupiter:junit-jupiter-api")
     implementation("org.junit.platform:junit-platform-launcher")
+    implementation(project(":allure-test-filter"))
     testAnnotationProcessor("org.slf4j:slf4j-simple")
     testAnnotationProcessor(project(":allure-descriptions-javadoc"))
     testImplementation("io.github.glytching:junit-extensions")
diff --git a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
index 60dc36185..10ff7c5e8 100644
--- a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
+++ b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatform.java
@@ -359,8 +359,10 @@ private void startTestCase(final TestIdentifier testIdentifier) {
         final String uuid = tests.getOrCreate(testIdentifier);
 
         final Optional<TestSource> testSource = testIdentifier.getSource();
-        final Optional<Method> testMethod = testSource.flatMap(this::getTestMethod);
-        final Optional<Class<?>> testClass = testSource.flatMap(this::getTestClass);
+        final Optional<Method> testMethod = testSource
+                .flatMap(AllureJunitPlatformUtils::getTestMethod);
+        final Optional<Class<?>> testClass = testSource
+                .flatMap(AllureJunitPlatformUtils::getTestClass);
 
         final TestResult result = new TestResult()
                 .setUuid(uuid)
@@ -384,7 +386,7 @@ private void startTestCase(final TestIdentifier testIdentifier) {
                 createLanguageLabel("java")
         ));
 
-        testSource.flatMap(this::getFullName).ifPresent(result::setFullName);
+        testSource.flatMap(AllureJunitPlatformUtils::getFullName).ifPresent(result::setFullName);
         testSource.map(this::getSourceLabels).ifPresent(result.getLabels()::addAll);
         testClass.ifPresent(aClass -> {
             final String suiteName = getDisplayName(aClass).orElse(aClass.getCanonicalName());
@@ -508,56 +510,6 @@ private List<Label> getSourceLabels(final TestSource source) {
         return Collections.emptyList();
     }
 
-    private Optional<String> getFullName(final TestSource source) {
-        if (source instanceof MethodSource) {
-            final MethodSource ms = (MethodSource) source;
-            return Optional.of(String.format("%s.%s", ms.getClassName(), ms.getMethodName()));
-        }
-        if (source instanceof ClassSource) {
-            final ClassSource cs = (ClassSource) source;
-            return Optional.ofNullable(cs.getClassName());
-        }
-        return Optional.empty();
-    }
-
-    private Optional<Class<?>> getTestClass(final TestSource source) {
-        if (source instanceof MethodSource) {
-            return getTestClass(((MethodSource) source).getClassName());
-        }
-        if (source instanceof ClassSource) {
-            return Optional.of(((ClassSource) source).getJavaClass());
-        }
-        return Optional.empty();
-    }
-
-    private Optional<Class<?>> getTestClass(final String className) {
-        try {
-            return Optional.of(Class.forName(className));
-        } catch (ClassNotFoundException e) {
-            LOGGER.trace("Could not get test class from test source {}", className, e);
-        }
-        return Optional.empty();
-    }
-
-    private Optional<Method> getTestMethod(final TestSource source) {
-        if (source instanceof MethodSource) {
-            return getTestMethod((MethodSource) source);
-        }
-        return Optional.empty();
-    }
-
-    private Optional<Method> getTestMethod(final MethodSource source) {
-        try {
-            final Class<?> aClass = Class.forName(source.getClassName());
-            return Stream.of(aClass.getDeclaredMethods())
-                    .filter(method -> MethodSource.from(method).equals(source))
-                    .findAny();
-        } catch (ClassNotFoundException e) {
-            LOGGER.trace("Could not get test method from method source {}", source, e);
-        }
-        return Optional.empty();
-    }
-
     private static class Uuids {
 
         private final Map<TestIdentifier, String> storage = new ConcurrentHashMap<>();
diff --git a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatformUtils.java b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatformUtils.java
new file mode 100644
index 000000000..4230cee0e
--- /dev/null
+++ b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllureJunitPlatformUtils.java
@@ -0,0 +1,88 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.junitplatform;
+
+import org.junit.platform.engine.TestSource;
+import org.junit.platform.engine.support.descriptor.ClassSource;
+import org.junit.platform.engine.support.descriptor.MethodSource;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.lang.reflect.Method;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+/* package-private */ final class AllureJunitPlatformUtils {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(AllureJunitPlatformUtils.class);
+
+    private AllureJunitPlatformUtils() {
+        throw new IllegalStateException("do not instance");
+    }
+
+    public static Optional<String> getFullName(final TestSource source) {
+        if (source instanceof MethodSource) {
+            final MethodSource ms = (MethodSource) source;
+            return Optional.of(String.format("%s.%s", ms.getClassName(), ms.getMethodName()));
+        }
+        if (source instanceof ClassSource) {
+            final ClassSource cs = (ClassSource) source;
+            return Optional.ofNullable(cs.getClassName());
+        }
+        return Optional.empty();
+    }
+
+    public static Optional<Class<?>> getTestClass(final TestSource source) {
+        if (source instanceof MethodSource) {
+            return getTestClass(((MethodSource) source).getClassName());
+        }
+        if (source instanceof ClassSource) {
+            return Optional.of(((ClassSource) source).getJavaClass());
+        }
+        return Optional.empty();
+    }
+
+    public static Optional<Class<?>> getTestClass(final String className) {
+        try {
+            return Optional.of(Class.forName(className));
+        } catch (ClassNotFoundException e) {
+            LOGGER.trace("Could not get test class from test source {}", className, e);
+        }
+        return Optional.empty();
+    }
+
+    public static Optional<Method> getTestMethod(final TestSource source) {
+        if (source instanceof MethodSource) {
+            return getTestMethod((MethodSource) source);
+        }
+        return Optional.empty();
+    }
+
+    public static Optional<Method> getTestMethod(final MethodSource source) {
+        try {
+            final Class<?> aClass = Class.forName(source.getClassName());
+            return Stream.of(aClass.getDeclaredMethods())
+                    .filter(method -> MethodSource.from(method).equals(source))
+                    .findAny();
+        } catch (ClassNotFoundException e) {
+            LOGGER.trace("Could not get test method from method source {}", source, e);
+        }
+        return Optional.empty();
+    }
+}
diff --git a/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilter.java b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilter.java
new file mode 100644
index 000000000..e43a76230
--- /dev/null
+++ b/allure-junit-platform/src/main/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilter.java
@@ -0,0 +1,129 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.junitplatform;
+
+import io.qameta.allure.model.Label;
+import io.qameta.allure.testfilter.FileTestPlanSupplier;
+import io.qameta.allure.testfilter.TestPlan;
+import io.qameta.allure.testfilter.TestPlanV1_0;
+import io.qameta.allure.util.AnnotationUtils;
+import org.junit.platform.engine.FilterResult;
+import org.junit.platform.engine.TestDescriptor;
+import org.junit.platform.engine.TestTag;
+import org.junit.platform.launcher.PostDiscoveryFilter;
+
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static io.qameta.allure.util.ResultsUtils.ALLURE_ID_LABEL_NAME;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class AllurePostDiscoveryFilter implements PostDiscoveryFilter {
+
+    private static final Pattern ID_TAG = Pattern.compile("^@?allure\\.id[:=](?<id>.+)$");
+
+    private final TestPlan testPlan;
+
+    public AllurePostDiscoveryFilter() {
+        this(new FileTestPlanSupplier().supply().orElse(null));
+    }
+
+    public AllurePostDiscoveryFilter(final TestPlan testPlan) {
+        this.testPlan = testPlan;
+    }
+
+    @Override
+    public FilterResult apply(final TestDescriptor object) {
+        if (Objects.isNull(testPlan)) {
+            return FilterResult.included("test plan is empty");
+        }
+        if (!object.isTest()) {
+            return FilterResult.included("filter only applied for tests");
+        }
+
+        final String allureId = findAllureId(object);
+        final String uniqueId = object.getUniqueId().toString();
+        final String fullName = object.getSource()
+                .flatMap(AllureJunitPlatformUtils::getFullName)
+                .orElse(null);
+
+        return FilterResult.includedIf(
+                isIncluded(testPlan, allureId, uniqueId, fullName)
+        );
+    }
+
+    private boolean isIncluded(final TestPlan testPlan,
+                               final String allureId,
+                               final String uniqueId,
+                               final String fullName) {
+        if (testPlan instanceof TestPlanV1_0) {
+            final TestPlanV1_0 tp = (TestPlanV1_0) testPlan;
+            return Objects.isNull(tp.getTests()) || tp.getTests()
+                    .stream()
+                    .filter(Objects::nonNull)
+                    .anyMatch(tc -> match(tc, allureId, uniqueId, fullName));
+        }
+        return true;
+    }
+
+    @SuppressWarnings("BooleanExpressionComplexity")
+    private boolean match(final TestPlanV1_0.TestCase tc,
+                          final String allureId,
+                          final String uniqueId,
+                          final String fullName) {
+        return Objects.nonNull(tc.getId()) && tc.getId().equals(allureId)
+                || Objects.nonNull(tc.getSelector()) && tc.getSelector().equals(uniqueId)
+                || Objects.nonNull(tc.getSelector()) && tc.getSelector().equals(fullName);
+    }
+
+    private String findAllureId(final TestDescriptor object) {
+        return object.getSource()
+                .flatMap(AllureJunitPlatformUtils::getTestMethod)
+                .flatMap(this::findAllureId)
+                .orElseGet(() -> findAllureId(object.getTags()));
+    }
+
+    private String findAllureId(final Collection<TestTag> tags) {
+        return tags.stream()
+                .map(TestTag::getName)
+                .map(t -> {
+                    final Matcher matcher = ID_TAG.matcher(t);
+                    return matcher.matches()
+                            ? Optional.ofNullable(matcher.group("id"))
+                            : Optional.<String>empty();
+                })
+                .filter(Optional::isPresent)
+                .map(Optional::get)
+                .filter(Objects::nonNull)
+                .findAny()
+                .orElse(null);
+    }
+
+    private Optional<String> findAllureId(final Method value) {
+        return AnnotationUtils.getLabels(value)
+                .stream()
+                .filter(l -> ALLURE_ID_LABEL_NAME.equals(l.getName()))
+                .map(Label::getValue)
+                .findAny();
+    }
+
+}
diff --git a/allure-junit-platform/src/main/services/org.junit.platform.launcher.PostDiscoveryFilter b/allure-junit-platform/src/main/services/org.junit.platform.launcher.PostDiscoveryFilter
new file mode 100644
index 000000000..94f98f34e
--- /dev/null
+++ b/allure-junit-platform/src/main/services/org.junit.platform.launcher.PostDiscoveryFilter
@@ -0,0 +1 @@
+io.qameta.allure.junitplatform.AllurePostDiscoveryFilter
\ No newline at end of file
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
index e9f010f9a..d0233f581 100644
--- a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTest.java
@@ -16,12 +16,7 @@
 package io.qameta.allure.junitplatform;
 
 import io.github.glytching.junit.extension.system.SystemProperty;
-import io.qameta.allure.Allure;
-import io.qameta.allure.AllureLifecycle;
 import io.qameta.allure.Issue;
-import io.qameta.allure.Step;
-import io.qameta.allure.aspects.AttachmentsAspects;
-import io.qameta.allure.aspects.StepsAspects;
 import io.qameta.allure.junitplatform.features.AllureIdAnnotationSupport;
 import io.qameta.allure.junitplatform.features.BrokenInAfterAllTests;
 import io.qameta.allure.junitplatform.features.BrokenInBeforeAllTests;
@@ -64,17 +59,9 @@
 import io.qameta.allure.model.TestResult;
 import io.qameta.allure.test.AllureFeatures;
 import io.qameta.allure.test.AllureResults;
-import io.qameta.allure.test.AllureResultsWriterStub;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.parallel.ResourceLock;
-import org.junit.platform.engine.discovery.ClassSelector;
-import org.junit.platform.engine.discovery.DiscoverySelectors;
-import org.junit.platform.launcher.Launcher;
-import org.junit.platform.launcher.LauncherDiscoveryRequest;
-import org.junit.platform.launcher.core.LauncherConfig;
-import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
-import org.junit.platform.launcher.core.LauncherFactory;
 
 import java.nio.charset.StandardCharsets;
 import java.util.Collection;
@@ -82,8 +69,8 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collectors;
-import java.util.stream.Stream;
 
+import static io.qameta.allure.junitplatform.AllureJunitPlatformTestUtils.runClasses;
 import static io.qameta.allure.junitplatform.features.TaggedTests.CLASS_TAG;
 import static io.qameta.allure.junitplatform.features.TaggedTests.METHOD_TAG;
 import static io.qameta.allure.test.AllurePredicates.hasLabel;
@@ -772,36 +759,4 @@ void shouldSupportAllureIdAnnotations() {
 
     }
 
-    @Step("Run classes {classes}")
-    private AllureResults runClasses(final Class<?>... classes) {
-        final AllureResultsWriterStub writerStub = new AllureResultsWriterStub();
-        final AllureLifecycle lifecycle = new AllureLifecycle(writerStub);
-
-        final ClassSelector[] classSelectors = Stream.of(classes)
-                .map(DiscoverySelectors::selectClass)
-                .toArray(ClassSelector[]::new);
-
-        final LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
-                .selectors(classSelectors)
-                .build();
-
-        final LauncherConfig config = LauncherConfig.builder()
-                .enableTestExecutionListenerAutoRegistration(false)
-                .addTestExecutionListeners(new AllureJunitPlatform(lifecycle))
-                .build();
-        final Launcher launcher = LauncherFactory.create(config);
-
-        final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
-        try {
-            Allure.setLifecycle(lifecycle);
-            StepsAspects.setLifecycle(lifecycle);
-            AttachmentsAspects.setLifecycle(lifecycle);
-            launcher.execute(request);
-            return writerStub;
-        } finally {
-            Allure.setLifecycle(defaultLifecycle);
-            StepsAspects.setLifecycle(defaultLifecycle);
-            AttachmentsAspects.setLifecycle(defaultLifecycle);
-        }
-    }
 }
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTestUtils.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTestUtils.java
new file mode 100644
index 000000000..b8d76cd08
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllureJunitPlatformTestUtils.java
@@ -0,0 +1,99 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.junitplatform;
+
+import io.qameta.allure.Allure;
+import io.qameta.allure.AllureLifecycle;
+import io.qameta.allure.Step;
+import io.qameta.allure.aspects.AttachmentsAspects;
+import io.qameta.allure.aspects.StepsAspects;
+import io.qameta.allure.test.AllureResults;
+import io.qameta.allure.test.AllureResultsWriterStub;
+import org.junit.platform.engine.discovery.ClassSelector;
+import org.junit.platform.engine.discovery.DiscoverySelectors;
+import org.junit.platform.launcher.Launcher;
+import org.junit.platform.launcher.LauncherDiscoveryRequest;
+import org.junit.platform.launcher.TestPlan;
+import org.junit.platform.launcher.core.LauncherConfig;
+import org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder;
+import org.junit.platform.launcher.core.LauncherFactory;
+
+import java.util.stream.Stream;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public final class AllureJunitPlatformTestUtils {
+
+    private AllureJunitPlatformTestUtils() {
+        throw new IllegalStateException("do not instance");
+    }
+
+    @Step("Run classes {classes}")
+    public static AllureResults runClasses(final Class<?>... classes) {
+        final AllureResultsWriterStub writerStub = new AllureResultsWriterStub();
+        final AllureLifecycle lifecycle = new AllureLifecycle(writerStub);
+
+        final ClassSelector[] classSelectors = Stream.of(classes)
+                .map(DiscoverySelectors::selectClass)
+                .toArray(ClassSelector[]::new);
+
+        final LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
+                .selectors(classSelectors)
+                .build();
+
+        final LauncherConfig config = LauncherConfig.builder()
+                .enableTestExecutionListenerAutoRegistration(false)
+                .addTestExecutionListeners(new AllureJunitPlatform(lifecycle))
+                .enablePostDiscoveryFilterAutoRegistration(false)
+                .build();
+        final Launcher launcher = LauncherFactory.create(config);
+
+        final AllureLifecycle defaultLifecycle = Allure.getLifecycle();
+        try {
+            Allure.setLifecycle(lifecycle);
+            StepsAspects.setLifecycle(lifecycle);
+            AttachmentsAspects.setLifecycle(lifecycle);
+            launcher.execute(request);
+            return writerStub;
+        } finally {
+            Allure.setLifecycle(defaultLifecycle);
+            StepsAspects.setLifecycle(defaultLifecycle);
+            AttachmentsAspects.setLifecycle(defaultLifecycle);
+        }
+    }
+
+    @Step("Build test plan for {classes}")
+    public static TestPlan buildPlan(final io.qameta.allure.testfilter.TestPlan testPlan,
+                                     final Class<?>... classes) {
+        final ClassSelector[] classSelectors = Stream.of(classes)
+                .map(DiscoverySelectors::selectClass)
+                .toArray(ClassSelector[]::new);
+
+        final LauncherDiscoveryRequest request = LauncherDiscoveryRequestBuilder.request()
+                .selectors(classSelectors)
+                .filters(new AllurePostDiscoveryFilter(testPlan))
+                .build();
+
+        final LauncherConfig config = LauncherConfig.builder()
+                .enableTestExecutionListenerAutoRegistration(false)
+                .enablePostDiscoveryFilterAutoRegistration(false)
+                .build();
+        final Launcher launcher = LauncherFactory.create(config);
+
+        return launcher.discover(request);
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilterTest.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilterTest.java
new file mode 100644
index 000000000..e03a1ec0b
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/AllurePostDiscoveryFilterTest.java
@@ -0,0 +1,112 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.junitplatform;
+
+import io.qameta.allure.junitplatform.features.PassedTests;
+import io.qameta.allure.junitplatform.features.TestsWithAllureId;
+import io.qameta.allure.testfilter.TestPlanV1_0;
+import org.junit.jupiter.api.Test;
+import org.junit.platform.launcher.TestIdentifier;
+import org.junit.platform.launcher.TestPlan;
+
+import java.util.Arrays;
+
+import static io.qameta.allure.junitplatform.AllureJunitPlatformTestUtils.buildPlan;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class AllurePostDiscoveryFilterTest {
+
+    @Test
+    void shouldRunAllTestsIfNoTestPlanProvided() {
+        final TestPlan testPlan = buildPlan(null, PassedTests.class);
+
+        final long testsCount = testPlan.countTestIdentifiers(TestIdentifier::isTest);
+
+        assertThat(testsCount)
+                .isEqualTo(3);
+    }
+
+    @Test
+    void shouldRunAllTestsIfEmptyTestPlanProvided() {
+        final TestPlan testPlan = buildPlan(new TestPlanV1_0(), PassedTests.class);
+
+        final long testsCount = testPlan.countTestIdentifiers(TestIdentifier::isTest);
+
+        assertThat(testsCount)
+                .isEqualTo(3);
+    }
+
+    @Test
+    void shouldFilterTestCasesByFullName() {
+        final TestPlan testPlan = buildPlan(
+                new TestPlanV1_0().setTests(Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setSelector("io.qameta.allure.junitplatform.features.PassedTests.second"),
+                        new TestPlanV1_0.TestCase()
+                                .setSelector("io.qameta.allure.junitplatform.features.PassedTests.first")
+                )),
+                PassedTests.class
+        );
+
+        final long testsCount = testPlan.countTestIdentifiers(TestIdentifier::isTest);
+
+        assertThat(testsCount)
+                .isEqualTo(2);
+    }
+
+    @Test
+    void shouldFilterTestCasesByUniqueId() {
+        final TestPlan testPlan = buildPlan(
+                new TestPlanV1_0().setTests(Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setSelector("[engine:junit-jupiter]/[class:io.qameta.allure.junitplatform.features.PassedTests]/[method:second()]"),
+                        new TestPlanV1_0.TestCase()
+                                .setSelector("[engine:junit-jupiter]/[class:io.qameta.allure.junitplatform.features.PassedTests]/[method:third()]")
+                )),
+                PassedTests.class
+        );
+
+        final long testsCount = testPlan.countTestIdentifiers(TestIdentifier::isTest);
+
+        assertThat(testsCount)
+                .isEqualTo(2);
+    }
+
+    @Test
+    void shouldFilterTestCasesByAllureId() {
+        final TestPlan testPlan = buildPlan(
+                new TestPlanV1_0().setTests(Arrays.asList(
+                        new TestPlanV1_0.TestCase()
+                                .setId("32"),
+                        new TestPlanV1_0.TestCase()
+                                .setId("34"),
+                        new TestPlanV1_0.TestCase()
+                                .setId("41"),
+                        new TestPlanV1_0.TestCase()
+                                .setId("48")
+                )),
+                TestsWithAllureId.class
+        );
+
+        final long testsCount = testPlan.countTestIdentifiers(TestIdentifier::isTest);
+
+        assertThat(testsCount)
+                .isEqualTo(3);
+    }
+}
diff --git a/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithAllureId.java b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithAllureId.java
new file mode 100644
index 000000000..26c8380d8
--- /dev/null
+++ b/allure-junit-platform/src/test/java/io/qameta/allure/junitplatform/features/TestsWithAllureId.java
@@ -0,0 +1,52 @@
+/*
+ *  Copyright 2019 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.junitplatform.features;
+
+import io.qameta.allure.AllureId;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class TestsWithAllureId {
+
+    @BeforeAll
+    static void doNothing(){
+
+    }
+
+    @Test
+    void first() {
+    }
+
+    @AllureId("32")
+    @Test
+    void second() {
+    }
+
+    @AllureId("48")
+    @Test
+    void third() {
+    }
+
+    @Tag("allure.id=34")
+    @Test
+    void oneMoreTest() {
+    }
+
+}
diff --git a/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java b/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java
index 1ddf6ebae..cb63aae33 100644
--- a/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java
+++ b/allure-junit4/src/test/java/io/qameta/allure/junit4/AllureJunit4Test.java
@@ -42,6 +42,7 @@
 import io.qameta.allure.test.AllureFeatures;
 import io.qameta.allure.test.AllureResults;
 import io.qameta.allure.test.AllureResultsWriterStub;
+
 import org.junit.jupiter.api.Test;
 import org.junit.runner.JUnitCore;
 
diff --git a/allure-test-filter/build.gradle.kts b/allure-test-filter/build.gradle.kts
new file mode 100644
index 000000000..7b2972876
--- /dev/null
+++ b/allure-test-filter/build.gradle.kts
@@ -0,0 +1,39 @@
+description = "Allure Test Filter"
+
+val agent: Configuration by configurations.creating
+
+dependencies {
+    agent("org.aspectj:aspectjweaver")
+    implementation("com.fasterxml.jackson.core:jackson-databind")
+    implementation(project(":allure-java-commons"))
+    testAnnotationProcessor("org.slf4j:slf4j-simple")
+    testAnnotationProcessor(project(":allure-descriptions-javadoc"))
+    testImplementation("io.github.glytching:junit-extensions")
+    testImplementation("org.assertj:assertj-core")
+    testImplementation("org.junit.jupiter:junit-jupiter-api")
+    testImplementation("org.junit.jupiter:junit-jupiter-params")
+    testImplementation("org.slf4j:slf4j-simple")
+    testImplementation(project(":allure-assertj"))
+    testImplementation(project(":allure-java-commons-test"))
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine")
+}
+
+tasks.jar {
+    manifest {
+        attributes(mapOf(
+                "Automatic-Module-Name" to "io.qameta.allure.testfilter"
+        ))
+    }
+    from("src/main/services") {
+        into("META-INF/services")
+    }
+}
+
+tasks.test {
+    systemProperty("junit.jupiter.execution.parallel.enabled", "false")
+    useJUnitPlatform()
+    exclude("**/features/*")
+    doFirst {
+        jvmArgs("-javaagent:${agent.singleFile}")
+    }
+}
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/FileTestPlanSupplier.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/FileTestPlanSupplier.java
new file mode 100644
index 000000000..204805b51
--- /dev/null
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/FileTestPlanSupplier.java
@@ -0,0 +1,91 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.testfilter;
+
+import com.fasterxml.jackson.core.JsonGenerator;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * The {@link TestPlanSupplier} that reads test plan from file, specified
+ * in {@code ALLURE_TESTPLAN_PATH} environment variable.
+ *
+ * @author charlie (Dmitry Baev).
+ */
+public class FileTestPlanSupplier implements TestPlanSupplier {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(FileTestPlanSupplier.class);
+
+    /**
+     * The possible environment variable names.
+     */
+    private static final String[] ENV_TESTPLAN_PATH = {"ALLURE_TESTPLAN_PATH", "AS_TESTPLAN_PATH"};
+
+    /**
+     * {@link ObjectMapper} to read test plan file.
+     */
+    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper()
+            .enable(JsonGenerator.Feature.IGNORE_UNKNOWN);
+
+    /**
+     * Supply test plan.
+     *
+     * @return the test plan.
+     */
+    @Override
+    public Optional<TestPlan> supply() {
+        final Optional<String> testPlanPath = Arrays.stream(ENV_TESTPLAN_PATH)
+                .map(System::getenv)
+                .filter(Objects::nonNull)
+                .filter(s -> !s.isEmpty())
+                .findFirst();
+
+        return testPlanPath
+                .flatMap(this::tryGetPath)
+                .filter(Files::exists)
+                .filter(Files::isRegularFile)
+                .flatMap(this::readTestPlan);
+    }
+
+    private Optional<TestPlan> readTestPlan(final Path path) {
+        try (InputStream stream = Files.newInputStream(path)) {
+            return Optional.of(OBJECT_MAPPER.readValue(stream, TestPlan.class));
+        } catch (IOException e) {
+            LOGGER.warn("could not read test plan file {}", path, e);
+            return Optional.empty();
+        }
+    }
+
+    private Optional<Path> tryGetPath(final String path) {
+        try {
+            return Optional.of(Paths.get(path));
+        } catch (Exception e) {
+            LOGGER.warn("could not read test plan file {}: invalid path", path);
+            return Optional.empty();
+        }
+    }
+
+}
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlan.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlan.java
new file mode 100644
index 000000000..a0c5b7c21
--- /dev/null
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlan.java
@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.testfilter;
+
+import com.fasterxml.jackson.annotation.JsonSubTypes;
+import com.fasterxml.jackson.annotation.JsonTypeInfo;
+
+/**
+ * Common interface for all test plan implementations.
+ *
+ * @author charlie (Dmitry Baev).
+ */
+@JsonTypeInfo(
+        use = JsonTypeInfo.Id.NAME,
+        property = "version",
+        defaultImpl = TestPlanUnknown.class
+)
+@JsonSubTypes({
+        @JsonSubTypes.Type(TestPlanV1_0.class)
+})
+public interface TestPlan {
+}
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanSupplier.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanSupplier.java
new file mode 100644
index 000000000..b3a2c27a7
--- /dev/null
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanSupplier.java
@@ -0,0 +1,35 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.testfilter;
+
+import java.util.Optional;
+
+/**
+ * Marker interface for all test plan suppliers.
+ *
+ * @author charlie (Dmitry Baev).
+ */
+@FunctionalInterface
+public interface TestPlanSupplier {
+
+    /**
+     * Supply test plan.
+     *
+     * @return the test plan.
+     */
+    Optional<TestPlan> supply();
+
+}
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanUnknown.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanUnknown.java
new file mode 100644
index 000000000..937a7c74a
--- /dev/null
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanUnknown.java
@@ -0,0 +1,27 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.testfilter;
+
+import java.io.Serializable;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+public class TestPlanUnknown implements TestPlan, Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+}
diff --git a/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanV1_0.java b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanV1_0.java
new file mode 100644
index 000000000..a74ccef9a
--- /dev/null
+++ b/allure-test-filter/src/main/java/io/qameta/allure/testfilter/TestPlanV1_0.java
@@ -0,0 +1,127 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.testfilter;
+
+import com.fasterxml.jackson.annotation.JsonTypeName;
+
+import java.io.Serializable;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+/**
+ * @author charlie (Dmitry Baev).
+ */
+@JsonTypeName("1.0")
+@SuppressWarnings({"TypeName", "PMD.CyclomaticComplexity"})
+public class TestPlanV1_0 implements TestPlan, Serializable {
+
+    private static final long serialVersionUID = 1L;
+
+    /**
+     * List of tests to run.
+     */
+    private List<TestCase> tests;
+
+    /**
+     * Gets the value of the tests property.
+     *
+     * @return tests.
+     */
+    public List<TestCase> getTests() {
+        return tests;
+    }
+
+    /**
+     * Sets the value of the tests property.
+     *
+     * @param tests the value to set.
+     * @return current instance.
+     */
+    public TestPlanV1_0 setTests(final List<TestCase> tests) {
+        this.tests = tests;
+        return this;
+    }
+
+    /**
+     * @param allureId value of @AllureId annotation, if not set pass null value
+     * @param selector selector of test method
+     * @return
+     */
+    public boolean isSelected(final String allureId, final String selector) {
+        return getTests().stream().map(test -> new String[]{test.getId(), test.getSelector()})
+                .flatMap(array -> Arrays.stream(array).filter(Objects::nonNull))
+                .anyMatch(item -> item.equals(selector) || item.equals(allureId));
+    }
+
+    /**
+     * Test plan test case. At least one of {@link #id} and {@link #selector} should be specified.
+     */
+    public static class TestCase implements Serializable {
+
+        private static final long serialVersionUID = 1L;
+
+        /**
+         * Test case id. Can be specified by providing {@code AS_ID} label.
+         */
+        private String id;
+
+        /**
+         * Selector that can be used to run test case. Some sort of unique id or full name of test.
+         */
+        private String selector;
+
+        /**
+         * Gets the value of the id property.
+         *
+         * @return id
+         */
+        public String getId() {
+            return id;
+        }
+
+        /**
+         * Sets the value of the id property.
+         *
+         * @param id the id to set.
+         * @return current instance.
+         */
+        public TestCase setId(final String id) {
+            this.id = id;
+            return this;
+        }
+
+        /**
+         * Gets the value of the selector property.
+         *
+         * @return id
+         */
+        public String getSelector() {
+            return selector;
+        }
+
+        /**
+         * Sets the value of the selector property.
+         *
+         * @param selector the selector to set.
+         * @return current instance.
+         */
+        public TestCase setSelector(final String selector) {
+            this.selector = selector;
+            return this;
+        }
+    }
+}
diff --git a/allure-testng/build.gradle.kts b/allure-testng/build.gradle.kts
index 36565c519..c48c6d44c 100644
--- a/allure-testng/build.gradle.kts
+++ b/allure-testng/build.gradle.kts
@@ -8,6 +8,7 @@ dependencies {
     agent("org.aspectj:aspectjweaver")
     api(project(":allure-java-commons"))
     implementation("org.testng:testng:$testNgVersion")
+    implementation(project(":allure-test-filter"))
     testAnnotationProcessor("org.slf4j:slf4j-simple")
     testAnnotationProcessor(project(":allure-descriptions-javadoc"))
     testImplementation("com.google.inject:guice")
diff --git a/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java
index 92fb3cfd9..d1e453055 100644
--- a/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java
+++ b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNg.java
@@ -40,6 +40,8 @@
 import org.testng.IConfigurationListener;
 import org.testng.IInvokedMethod;
 import org.testng.IInvokedMethodListener;
+import org.testng.IMethodInstance;
+import org.testng.IMethodInterceptor;
 import org.testng.ISuite;
 import org.testng.ISuiteListener;
 import org.testng.ITestClass;
@@ -97,14 +99,15 @@
  * Allure TestNG listener.
  */
 @SuppressWarnings({
-        "PMD.ExcessiveImports", "PMD.TooManyMethods", "PMD.GodClass",
+        "PMD.ExcessiveImports", "PMD.TooManyMethods", "PMD.GodClass", "PMD.CyclomaticComplexity",
         "ClassFanOutComplexity", "ClassDataAbstractionCoupling", "PMD.ExcessiveClassLength"
 })
 public class AllureTestNg implements
         ISuiteListener,
         ITestListener,
         IInvokedMethodListener,
-        IConfigurationListener {
+        IConfigurationListener,
+        IMethodInterceptor {
 
     private static final Logger LOGGER = LoggerFactory.getLogger(AllureTestNg.class);
 
@@ -139,19 +142,30 @@ public class AllureTestNg implements
     );
 
     private final AllureLifecycle lifecycle;
+    private final AllureTestNgTestFilter testFilter;
 
-    public AllureTestNg(final AllureLifecycle lifecycle) {
+    public AllureTestNg(final AllureLifecycle lifecycle, final AllureTestNgTestFilter testFilter) {
         this.lifecycle = lifecycle;
+        this.testFilter = testFilter;
+    }
+
+    public AllureTestNg(final AllureLifecycle lifecycle) {
+        this(lifecycle, new AllureTestNgTestFilter());
     }
 
     public AllureTestNg() {
-        this.lifecycle = Allure.getLifecycle();
+        this(Allure.getLifecycle(), new AllureTestNgTestFilter());
     }
 
     public AllureLifecycle getLifecycle() {
         return lifecycle;
     }
 
+    @Override
+    public List<IMethodInstance> intercept(final List<IMethodInstance> methods, final ITestContext context) {
+        return testFilter.intercept(methods, context);
+    }
+
     @Override
     public void onStart(final ISuite suite) {
         final TestResultContainer result = new TestResultContainer()
@@ -179,6 +193,7 @@ public void onStart(final ITestContext context) {
         context.getExcludedMethods().stream()
                 .filter(ITestNGMethod::isTest)
                 .filter(method -> !method.getEnabled())
+                .filter(testFilter::isSelected)
                 .forEach(method -> createFakeResult(context, method));
     }
 
diff --git a/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNgTestFilter.java b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNgTestFilter.java
new file mode 100644
index 000000000..b07ace62d
--- /dev/null
+++ b/allure-testng/src/main/java/io/qameta/allure/testng/AllureTestNgTestFilter.java
@@ -0,0 +1,87 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.testng;
+
+import io.qameta.allure.AllureId;
+import io.qameta.allure.testfilter.FileTestPlanSupplier;
+import io.qameta.allure.testfilter.TestPlan;
+import io.qameta.allure.testfilter.TestPlanUnknown;
+import io.qameta.allure.testfilter.TestPlanV1_0;
+
+import java.lang.reflect.Method;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+import org.testng.IMethodInstance;
+import org.testng.IMethodInterceptor;
+import org.testng.ITestContext;
+import org.testng.ITestNGMethod;
+import org.testng.internal.ConstructorOrMethod;
+
+public class AllureTestNgTestFilter implements IMethodInterceptor {
+
+    private final TestPlan testPlan;
+
+    public AllureTestNgTestFilter() {
+        this.testPlan = new FileTestPlanSupplier().supply().orElse(new TestPlanUnknown());
+    }
+
+    public AllureTestNgTestFilter(final TestPlan testPlan) {
+        this.testPlan = testPlan;
+    }
+
+    @Override
+    public List<IMethodInstance> intercept(final List<IMethodInstance> methods, final ITestContext context) {
+        if (testPlan instanceof TestPlanV1_0) {
+            return methods.stream()
+                    .filter(instance -> isSelected(instance.getMethod()))
+                    .collect(Collectors.toList());
+        } else {
+            return methods;
+        }
+    }
+
+    public boolean isSelected(final ITestNGMethod instance) {
+        if (testPlan instanceof TestPlanV1_0) {
+            return isSelected(instance, (TestPlanV1_0) testPlan);
+        } else {
+            return true;
+        }
+    }
+
+    public boolean isSelected(final ITestNGMethod testNGMethod, final TestPlanV1_0 testPlan) {
+        final Optional<Method> method = Optional.ofNullable(testNGMethod)
+                .map(ITestNGMethod::getConstructorOrMethod)
+                .map(ConstructorOrMethod::getMethod);
+
+        if (method.isPresent()) {
+            final String selector = getSelector(method.get());
+            final String allureId = method
+                    .filter(m -> m.isAnnotationPresent(AllureId.class))
+                    .map(m -> m.getAnnotation(AllureId.class))
+                    .map(AllureId::value).orElse(null);
+            return testPlan.isSelected(allureId, selector);
+        }
+        return false;
+    }
+
+    private String getSelector(final Method method) {
+        return String.format("%s.%s",
+                method.getDeclaringClass().getCanonicalName(),
+                method.getName());
+    }
+}
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java b/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java
index 326189c89..a3314a187 100644
--- a/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/AllureTestNgTest.java
@@ -36,6 +36,9 @@
 import io.qameta.allure.test.AllureFeatures;
 import io.qameta.allure.test.AllureResults;
 import io.qameta.allure.test.AllureResultsWriterStub;
+import io.qameta.allure.testfilter.TestPlan;
+import io.qameta.allure.testfilter.TestPlanV1_0;
+import io.qameta.allure.testng.samples.TestsWithIdForFilter;
 import org.assertj.core.api.Condition;
 import org.assertj.core.groups.Tuple;
 import org.testng.ITestNGListener;
@@ -1270,4 +1273,128 @@ private static void checkTestJavadocDescriptions(List<TestResult> results, Strin
                 .containsOnly(expectedDescriptionHtml);
     }
 
+    private final TestPlanV1_0.TestCase onlyId2 = new TestPlanV1_0.TestCase().setId("2");
+    private final TestPlanV1_0.TestCase onlyId4 = new TestPlanV1_0.TestCase().setId("4");
+
+    private final TestPlanV1_0.TestCase test1 = new TestPlanV1_0.TestCase().setId("1")
+            .setSelector("io.qameta.allure.testng.samples.TestsWithIdForFilter.test1");
+    private final TestPlanV1_0.TestCase test2 = new TestPlanV1_0.TestCase()
+            .setId("2")
+            .setSelector("io.qameta.allure.testng.samples.TestsWithIdForFilter.test2");
+    private final TestPlanV1_0.TestCase test3 = new TestPlanV1_0.TestCase()
+            .setId("3")
+            .setSelector("io.qameta.allure.testng.samples.TestsWithIdForFilter.test3");
+    private final TestPlanV1_0.TestCase otherId = new TestPlanV1_0.TestCase().setId("4")
+            .setSelector("io.qameta.allure.testng.samples.TestsWithIdForFilter.test1");
+    private final TestPlanV1_0.TestCase skipped = new TestPlanV1_0.TestCase().setId("5")
+            .setSelector("io.qameta.allure.testng.samples.TestsWithIdForFilter.skipped");
+    private final TestPlanV1_0.TestCase correctIdIncorrectSelector = new TestPlanV1_0.TestCase()
+            .setId("3")
+            .setSelector("io.qameta.allure.testng.samples.TestsWithIdForFilter.test3");
+    private final TestPlanV1_0.TestCase correctIdIncorrectSelectorFailed = new TestPlanV1_0.TestCase()
+            .setId("6")
+            .setSelector("allure.junit4.samples.TestsWithIdForFilter.test3");
+
+
+    @Test
+    @AllureFeatures.Filtration
+    public void simpleFiltration()  {
+        TestPlanV1_0 plan = new TestPlanV1_0().setTests(Arrays.asList(test1, test2, test3));
+        List<TestResult> testResults = runTestPlan(plan, TestsWithIdForFilter.class).getTestResults();
+
+        assertThat(testResults)
+                .hasSize(3)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .contains(
+                        tuple("test1", Status.PASSED),
+                        tuple("test2", Status.PASSED),
+                        tuple("test3", Status.PASSED)
+                );
+    }
+
+    @Test
+    @AllureFeatures.Filtration
+    public void onlyId()  {
+        TestPlanV1_0 plan = new TestPlanV1_0().setTests(Arrays.asList(onlyId2, onlyId4));
+        List<TestResult> testResults = runTestPlan(plan, TestsWithIdForFilter.class).getTestResults();
+
+        assertThat(testResults)
+                .hasSize(2)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .contains(
+                        tuple("test4", Status.PASSED),
+                        tuple("test2", Status.PASSED)
+                );
+    }
+
+    @Test
+    @AllureFeatures.Filtration
+    public void idAssignToOtherTest() {
+        TestPlanV1_0 plan = new TestPlanV1_0().setTests(Arrays.asList(otherId));
+        List<TestResult> testResults = runTestPlan(plan, TestsWithIdForFilter.class).getTestResults();
+
+        assertThat(testResults)
+                .hasSize(2)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .contains(
+                        tuple("test1", Status.PASSED),
+                        tuple("test4", Status.PASSED)
+                );
+    }
+
+    @Test
+    @AllureFeatures.Filtration
+    public void skippedTest() {
+        TestPlanV1_0 plan = new TestPlanV1_0().setTests(Arrays.asList(skipped));
+        List<TestResult> testResults = runTestPlan(plan, TestsWithIdForFilter.class).getTestResults();
+        assertThat(testResults)
+                .hasSize(1)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .contains(
+                        tuple("skipped", null)
+                );
+    }
+
+    @Test
+    @AllureFeatures.Filtration
+    public void correctIdIncorrectSelector()  {
+        TestPlanV1_0 plan = new TestPlanV1_0().setTests(
+                Arrays.asList(test1, test2, correctIdIncorrectSelector, correctIdIncorrectSelectorFailed)
+        );
+        List<TestResult> testResults = runTestPlan(plan, TestsWithIdForFilter.class).getTestResults();
+        assertThat(testResults)
+                .hasSize(4)
+                .extracting(TestResult::getName, TestResult::getStatus)
+                .contains(
+                        tuple("test1", Status.PASSED),
+                        tuple("test2", Status.PASSED),
+                        tuple("test3", Status.PASSED),
+                        tuple("test6", Status.FAILED)
+                );
+    }
+
+    public AllureResultsWriterStub runTestPlan(TestPlan plan, final Class<?> ... testClasses) {
+        final AllureResultsWriterStub results = new AllureResultsWriterStub();
+        final AllureLifecycle lifecycle = new AllureLifecycle(results);
+        final AllureTestNg adapter = new AllureTestNg(lifecycle, new AllureTestNgTestFilter(plan));
+        TestNG testNG = new TestNG(false);
+        testNG.addListener((ITestNGListener) adapter);
+        testNG.setTestClasses(testClasses);
+        testNG.setOutputDirectory("build/test-output");
+
+
+        final AllureLifecycle cached = Allure.getLifecycle();
+        try {
+            Allure.setLifecycle(lifecycle);
+            StepsAspects.setLifecycle(lifecycle);
+            AttachmentsAspects.setLifecycle(lifecycle);
+            testNG.run();
+            return results;
+        } finally {
+            Allure.setLifecycle(cached);
+            StepsAspects.setLifecycle(cached);
+            AttachmentsAspects.setLifecycle(cached);
+        }
+    }
+
 }
diff --git a/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithIdForFilter.java b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithIdForFilter.java
new file mode 100644
index 000000000..70bcdcde4
--- /dev/null
+++ b/allure-testng/src/test/java/io/qameta/allure/testng/samples/TestsWithIdForFilter.java
@@ -0,0 +1,53 @@
+/*
+ *  Copyright 2020 Qameta Software OÜ
+ *
+ *  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 io.qameta.allure.testng.samples;
+
+import io.qameta.allure.AllureId;
+import static org.assertj.core.api.Assertions.assertThat;
+import org.testng.annotations.Test;
+
+public class TestsWithIdForFilter {
+
+    @Test
+    @AllureId("1")
+    public void test1() {
+    }
+
+    @Test
+    @AllureId("2")
+    public void test2() {
+    }
+
+    @Test
+    public void test3() {
+    }
+
+    @Test
+    @AllureId("4")
+    public void test4() {
+    }
+
+    @Test(enabled = false)
+    @AllureId("5")
+    public void skipped() {
+    }
+
+    @Test
+    @AllureId("6")
+    public void test6() {
+        assertThat(true).isFalse();
+    }
+}
diff --git a/settings.gradle.kts b/settings.gradle.kts
index 011c4a85c..d2093d40a 100644
--- a/settings.gradle.kts
+++ b/settings.gradle.kts
@@ -21,6 +21,7 @@ include("allure-junit-platform")
 include("allure-junit4")
 include("allure-junit4-aspect")
 include("allure-junit5")
+include("allure-junit5-assert")
 include("allure-model")
 include("allure-okhttp")
 include("allure-okhttp3")
@@ -30,5 +31,6 @@ include("allure-selenide")
 include("allure-servlet-api")
 include("allure-spock")
 include("allure-spring-web")
+include("allure-test-filter")
 include("allure-testng")
-include("allure-junit5-assert")
+