diff --git a/README.md b/README.md
index 2f084df..563e1b2 100644
--- a/README.md
+++ b/README.md
@@ -90,16 +90,68 @@ Transformations:
   -S, --transform-suffix <SUFFIX>  Append a suffix to each word
   -C, --transform-capitalize       Capitalize each word
 
-Filtering:
-  -F, --filter-contains <STRING>     Contains the specified string
-      --filter-starts-with <STRING>  Start with the specified string
-      --filter-ends-with <STRING>    End with the specified string
-      --filter-regex <REGEX>         Filter out words that match the specified regex
-      --filter-max-length <LENGTH>   Maximum length
-      --filter-min-length <LENGTH>   Minimum length
-      --filter-length <LENGTH>       Exact length
+Wordlist Filtering:
+      --wordlist-filter-contains <STRING>
+          Contains the specified string [aliases: wfc]
+      --wordlist-filter-starts-with <STRING>
+          Start with the specified string [aliases: wfs]
+      --wordlist-filter-ends-with <STRING>
+          End with the specified string [aliases: wfe]
+      --wordlist-filter-regex <REGEX>
+          Match the specified regex [aliases: wfr]
+      --wordlist-filter-length <LENGTH>
+          Length range e.g.: 5, 5-10, 5,10,15, >5, <5 [aliases: wfl]
+
+Response Filtering:
+      --filter-status-code <CODE>    Reponse status code, e.g.: 200, 200-300, 200,300,400, >200, <200 [aliases: fsc]
+      --filter-contains <STRING>     Contains the specified string [aliases: fc]
+      --filter-starts-with <STRING>  Start with the specified string [aliases: fs]
+      --filter-ends-with <STRING>    End with the specified string [aliases: fe]
+      --filter-regex <REGEX>         Match the specified regex [aliases: fr]
+      --filter-length <LENGTH>       Response length e.g.: 100, >100, <100, 100-200, 100,200,300 [aliases: fl]
+      --filter-time <TIME>           Response time range in milliseconds e.g.: >1000, <1000, 1000-2000 [aliases: ft]
 ```
 
+### Inputting ranges
+
+In some cases (`<RANGE>`), you may want to input a range of values. 
+You can use the following formats:
+
+| Format     | Description                               |
+| :--------- | :---------------------------------------- |
+| `5`        | Exactly `5`                               |
+| `5-10`     | Between `5` and `10` (inclusive)          |
+| `5,10`     | Exactly `5` or `10`                       |
+| `>5`       | Greater than `5`                          |
+| `<5`       | Less than `5`                             |
+| `5,10,15`  | Exactly `5`, `10`, or `15`                |
+| `>5,10,15` | Greater than `5`, or exactly `10` or `15` |
+
+I will let you figure out the rest of the combinations.
+
+### Response Filtering
+
+To cherry-pick the responses, you can use the `--filter-*` flags to filter specific responses. For example, to only show responses that contain `admin`:
+
+```bash
+rwalk https://example.com path/to/wordlist.txt --filter-contains admin
+```
+
+or only requests that took more than `1` second:
+
+```bash
+rwalk https://example.com path/to/wordlist.txt --filter-time ">1000"
+```
+
+Available filters:
+
+- `--filter-starts-with` _`<STRING>`_ or `--fs`
+- `--filter-ends-with` _`<STRING>`_ or `--fe`
+- `--filter-contains` _`<STRING>`_ or `--fc`
+- `--filter-regex` _`<REGEX>`_ or `--fr`
+- `--filter-length` _`<LENGTH>`_ or `--fl`
+- `--filter-status-code` _`<CODE>`_ or `--fsc`
+
 ### Wordlists
 
 You can pass multiple wordlists to rwalk. For example:
@@ -112,26 +164,30 @@ rwalk will merge the wordlists and remove duplicates. You can also apply filters
 
 > **Note:** A checksum is computed for the wordlists and stored in case you abort the scan. If you resume the scan, rwalk will only load the wordlists if the checksums match. See [Saving progress](#saving-and-resuming-scans) for more information.
 
-### Filters
 
-You can filter out words from the wordlist by using the `--filter-*` flags. For example, to filter out all words that start with `admin`:
+### Wordlist Filters
+
+> **Warning:** These options filter <u>**out**</u> the words from the wordlist. For example, if you use `--wordlist-filter-starts-with admin`, all words that start with `admin` will be <u>**removed**</u> from the wordlist.
+> Don't confuse this with [Response Filtering](#response-filtering) which filters <u>**in**</u> responses.
+
+You can filter <u>**out**</u> words from the wordlist by using the `--wordlist-filter-*` (`--wf*`) flags. For example, to filter out all words that start with `admin`:
 
 ```bash
-rwalk https://example.com path/to/wordlist.txt --filter-starts-with admin
+rwalk https://example.com path/to/wordlist.txt --wordlist-filter-starts-with admin
 ```
 
 Available filters:
 
-- `--filter-starts-with` _`<STRING>`_
-- `--filter-ends-with` _`<STRING>`_
-- `--filter-contains` _`<STRING>`_
-- `--filter-regex` _`<REGEX>`_
-- `--filter-length` _`<LENGTH>`_
-- `--filter-min-length` _`<LENGTH>`_
-- `--filter-max-length` _`<LENGTH>`_
+- `--wordlist-filter-starts-with` _`<STRING>`_ or `--wfs`
+- `--wordlist-filter-ends-with` _`<STRING>`_ or `--wfe` 
+- `--wordlist-filter-contains` _`<STRING>`_ or `--wfc`
+- `--wordlist-filter-regex` _`<REGEX>`_ or `--wfr` 
+- `--wordlist-filter-length` _`<LENGTH>`_ or `--wfl` 
+- `--wordlist-filter-min-length` _`<LENGTH>`_ or `--wfm`
+- `--wordlist-filter-max-length` _`<LENGTH>`_ or `--wfx`
 
 
-### Transformations
+### Wordlist Transformations
 
 To quickly modify the wordlist, you can use the `--transform-*` flags. For example, to add a prefix to all words in the wordlist:
 
@@ -141,11 +197,14 @@ rwalk https://example.com path/to/wordlist.txt --transform-prefix "."
 
 Available transformations:
 
-- `--transform-prefix` _`<PREFIX>`_
-- `--transform-suffix` _`<SUFFIX>`_
-- `--transform-upper`
-- `--transform-lower`
-- `--transform-capitalize`
+- `--transform-prefix` _`<PREFIX>`_ or `-P`
+- `--transform-suffix` _`<SUFFIX>`_ or `-S`
+- `--transform-upper` or `-U`
+- `--transform-lower` or `-L`
+- `--transform-capitalize` or `-C`
+
+
+
 
 ### Throttling
 
@@ -227,8 +286,6 @@ Each tool was run `10` times with `100` threads. The results are below:
 | `dirsearch` | 14.263 ± 0.250 |  13.861 |  14.719 | 2.70 ± 0.07 |
 | `ffuf`      |  5.285 ± 0.090 |   5.154 |   5.358 |        1.00 |
 
-[ffuf](https://github.com/ffuf/ffuf) is the fastest tool... but not by much. rwalk is only `1.15x` slower than ffuf and ~`2.5x` faster than dirsearch. Not bad for a first release!
-
 ## License
 
 Licensed under the [MIT License](LICENSE).
diff --git a/src/cli.rs b/src/cli.rs
index 6fbeb9c..6a2eea5 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -2,7 +2,7 @@ use clap::Parser;
 use lazy_static::lazy_static;
 use url::Url;
 
-use crate::constants::SAVE_FILE;
+use crate::{constants::SAVE_FILE, utils::parse_range_input};
 #[derive(Parser, Clone, Debug)]
 #[clap(
     version,
@@ -80,26 +80,51 @@ pub struct Opts {
     pub transform_capitalize: bool,
 
     /// Contains the specified string
-    #[clap(short='F', long, help_heading = Some("Filtering"), value_name = "STRING")]
+    #[clap(long, help_heading = Some("Wordlist Filtering"), value_name = "STRING", visible_alias = "wfc")]
+    pub wordlist_filter_contains: Option<String>,
+    /// Start with the specified string
+    #[clap(long, help_heading = Some("Wordlist Filtering"), value_name = "STRING", visible_alias = "wfs")]
+    pub wordlist_filter_starts_with: Option<String>,
+    /// End with the specified string
+    #[clap(long, help_heading = Some("Wordlist Filtering"), value_name = "STRING", visible_alias = "wfe")]
+    pub wordlist_filter_ends_with: Option<String>,
+    /// Match the specified regex
+    #[clap(long, help_heading = Some("Wordlist Filtering"), value_name = "REGEX", visible_alias = "wfr")]
+    pub wordlist_filter_regex: Option<String>,
+    /// Length range
+    /// e.g.: 5, 5-10, 5,10,15, >5, <5
+    #[clap(long, help_heading = Some("Wordlist Filtering"), value_name = "RANGE", visible_alias = "wfl", value_parser(parse_cli_range_input))]
+    pub wordlist_filter_length: Option<String>,
+
+    /// Reponse status code,
+    /// e.g.: 200, 200-300, 200,300,400, >200, <200
+    #[clap(long, help_heading = Some("Response Filtering"), value_name = "RANGE", visible_alias = "fsc", value_parser(parse_cli_range_input))]
+    pub filter_status_code: Option<String>,
+    /// Contains the specified string
+    #[clap(long, help_heading = Some("Response Filtering"), value_name = "STRING", visible_alias = "fc")]
     pub filter_contains: Option<String>,
     /// Start with the specified string
-    #[clap(long, help_heading = Some("Filtering"), value_name = "STRING")]
+    #[clap(long, help_heading = Some("Response Filtering"), value_name = "STRING", visible_alias = "fs")]
     pub filter_starts_with: Option<String>,
     /// End with the specified string
-    #[clap(long, help_heading = Some("Filtering"), value_name = "STRING")]
+    #[clap(long, help_heading = Some("Response Filtering"), value_name = "STRING", visible_alias = "fe")]
     pub filter_ends_with: Option<String>,
-    /// Filter out words that match the specified regex
-    #[clap(long, help_heading = Some("Filtering"), value_name = "REGEX")]
+    /// Match the specified regex
+    #[clap(long, help_heading = Some("Response Filtering"), value_name = "REGEX", visible_alias = "fr")]
     pub filter_regex: Option<String>,
-    /// Maximum length
-    #[clap(long, help_heading = Some("Filtering"), value_name = "LENGTH")]
-    pub filter_max_length: Option<usize>,
-    /// Minimum length
-    #[clap(long, help_heading = Some("Filtering"), value_name = "LENGTH")]
-    pub filter_min_length: Option<usize>,
-    /// Exact length
-    #[clap(long, help_heading = Some("Filtering"), value_name = "LENGTH")]
-    pub filter_length: Option<usize>,
+    /// Response length
+    /// e.g.: 100, >100, <100, 100-200, 100,200,300
+    #[clap(long, help_heading = Some("Response Filtering"), value_name = "RANGE", visible_alias = "fl", value_parser(parse_cli_range_input))]
+    pub filter_length: Option<String>,
+    /// Response time range in milliseconds
+    /// e.g.: >1000, <1000, 1000-2000
+    #[clap(long, help_heading = Some("Response Filtering"), value_name = "RANGE", visible_alias = "ft", value_parser(parse_cli_range_input))]
+    pub filter_time: Option<String>,
+}
+
+fn parse_cli_range_input(s: &str) -> Result<String, String> {
+    parse_range_input(s)?;
+    Ok(s.to_string())
 }
 
 fn parse_url(s: &str) -> Result<String, String> {
diff --git a/src/core.rs b/src/core.rs
index 9dfced3..2bd53fb 100644
--- a/src/core.rs
+++ b/src/core.rs
@@ -16,6 +16,7 @@ use crate::{
     cli::OPTS,
     constants::{ERROR, STATUS_CODES, SUCCESS, WARNING},
     tree::{Tree, TreeData},
+    utils::is_response_filtered,
 };
 
 pub async fn start(
@@ -143,13 +144,26 @@ pub async fn start(
                             tokio::time::sleep(sleep).await;
                         }
                         match response {
-                            Ok(response) => {
-                                if STATUS_CODES
-                                    .iter()
-                                    .any(|x| x.contains(&response.status().as_u16()))
+                            Ok(mut response) => {
+                                let mut text = String::new();
+                                while let Ok(chunk) = response.chunk().await {
+                                    if let Some(chunk) = chunk {
+                                        text.push_str(&String::from_utf8_lossy(&chunk));
+                                    } else {
+                                        break;
+                                    }
+                                }
+                                let status_code = response.status().as_u16();
+                                let filtered = is_response_filtered(
+                                    &text,
+                                    status_code,
+                                    t1.elapsed().as_millis() as u16,
+                                );
+
+                                if filtered && STATUS_CODES.iter().any(|x| x.contains(&status_code))
                                 {
                                     progress.println(format!(
-                                        "{} {} {}",
+                                        "{} {} {} {}",
                                         if response.status().is_success() {
                                             SUCCESS.to_string().green()
                                         } else if response.status().is_redirection() {
@@ -158,7 +172,12 @@ pub async fn start(
                                             ERROR.to_string().red()
                                         },
                                         response.status().as_str().bold(),
-                                        url
+                                        url,
+                                        format!(
+                                            "{}ms",
+                                            t1.elapsed().as_millis().to_string().bold()
+                                        )
+                                        .dimmed()
                                     ));
                                     // Check if this path is already in the tree
                                     let mut found = false;
@@ -175,7 +194,7 @@ pub async fn start(
                                                 url: url.clone(),
                                                 depth: data.depth + 1,
                                                 path: word.clone(),
-                                                status_code: response.status().as_u16(),
+                                                status_code,
                                             },
                                             Some(previous_node.clone()),
                                         );
diff --git a/src/main.rs b/src/main.rs
index b8a05e5..5bb80cc 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -61,6 +61,12 @@ async fn main() -> Result<()> {
                 .to_string()
                 .bold()
         );
+    } else {
+        println!(
+            "{} {} words loaded",
+            INFO.to_string().blue(),
+            before.to_string().bold()
+        );
     }
     if words.len() == 0 {
         println!("{} No words found in wordlists", ERROR.to_string().red());
diff --git a/src/utils.rs b/src/utils.rs
index 7f76e30..1c8e74b 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -64,34 +64,27 @@ pub fn get_emoji_for_status_code(status_code: u16) -> String {
 }
 
 pub fn apply_filters(words: &mut Vec<String>) -> Result<()> {
-    if OPTS.filter_contains.is_some() {
-        let filter_contains = OPTS.filter_contains.clone().unwrap();
+    if OPTS.wordlist_filter_contains.is_some() {
+        let filter_contains = OPTS.wordlist_filter_contains.clone().unwrap();
         words.retain(|word| word.contains(&filter_contains));
     }
-    if OPTS.filter_starts_with.is_some() {
-        let filter_starts_with = OPTS.filter_starts_with.clone().unwrap();
+    if OPTS.wordlist_filter_starts_with.is_some() {
+        let filter_starts_with = OPTS.wordlist_filter_starts_with.clone().unwrap();
         words.retain(|word| word.starts_with(&filter_starts_with));
     }
-    if OPTS.filter_ends_with.is_some() {
-        let filter_ends_with = OPTS.filter_ends_with.clone().unwrap();
+    if OPTS.wordlist_filter_ends_with.is_some() {
+        let filter_ends_with = OPTS.wordlist_filter_ends_with.clone().unwrap();
         words.retain(|word| word.ends_with(&filter_ends_with));
     }
-    if OPTS.filter_regex.is_some() {
-        let filter_regex = OPTS.filter_regex.clone().unwrap();
+    if OPTS.wordlist_filter_regex.is_some() {
+        let filter_regex = OPTS.wordlist_filter_regex.clone().unwrap();
         let re = regex::Regex::new(&filter_regex)?;
         words.retain(|word| re.is_match(&word));
     }
-    if OPTS.filter_length.is_some() {
-        let filter_length = OPTS.filter_length.clone().unwrap();
-        words.retain(|word| word.len() == filter_length);
-    }
-    if OPTS.filter_min_length.is_some() {
-        let filter_min_length = OPTS.filter_min_length.clone().unwrap();
-        words.retain(|word| word.len() >= filter_min_length);
-    }
-    if OPTS.filter_max_length.is_some() {
-        let filter_max_length = OPTS.filter_max_length.clone().unwrap();
-        words.retain(|word| word.len() <= filter_max_length);
+    if OPTS.wordlist_filter_length.is_some() {
+        let filter_length = OPTS.wordlist_filter_length.clone().unwrap();
+        let parsed_filter_length = parse_range_input(&filter_length).unwrap();
+        words.retain(|word| check_range(&parsed_filter_length, word.len()));
     }
 
     Ok(())
@@ -130,3 +123,104 @@ pub fn apply_transformations(words: &mut Vec<String>) {
         });
     }
 }
+
+pub fn is_response_filtered(res_text: &str, status_code: u16, time: u16) -> bool {
+    if OPTS.filter_time.is_some() {
+        let filter_time = OPTS.filter_time.clone().unwrap();
+        let parsed_filter_time = parse_range_input(&filter_time).unwrap();
+        if !check_range(&parsed_filter_time, time as usize) {
+            return false;
+        }
+    }
+    if OPTS.filter_status_code.is_some() {
+        let filter_status_code = OPTS.filter_status_code.clone().unwrap();
+        let parsed_filter_status_code = parse_range_input(&filter_status_code).unwrap();
+        if !check_range(&parsed_filter_status_code, status_code as usize) {
+            return false;
+        }
+    }
+    if OPTS.filter_contains.is_some() {
+        let filter_contains = OPTS.filter_contains.clone().unwrap();
+        if !res_text.contains(&filter_contains) {
+            return false;
+        }
+    }
+    if OPTS.filter_starts_with.is_some() {
+        let filter_starts_with = OPTS.filter_starts_with.clone().unwrap();
+        if !res_text.starts_with(&filter_starts_with) {
+            return false;
+        }
+    }
+    if OPTS.filter_ends_with.is_some() {
+        let filter_ends_with = OPTS.filter_ends_with.clone().unwrap();
+        if !res_text.ends_with(&filter_ends_with) {
+            return false;
+        }
+    }
+    if OPTS.filter_regex.is_some() {
+        let filter_regex = OPTS.filter_regex.clone().unwrap();
+        let re = regex::Regex::new(&filter_regex).unwrap();
+        if !re.is_match(&res_text) {
+            return false;
+        }
+    }
+    if OPTS.filter_length.is_some() {
+        let filter_length = OPTS.filter_length.clone().unwrap();
+        let parsed_filter_length = parse_range_input(&filter_length).unwrap();
+        if !check_range(&parsed_filter_length, res_text.len()) {
+            return false;
+        }
+    }
+
+    true
+}
+pub fn check_range(ranges: &Vec<(usize, usize)>, num: usize) -> bool {
+    for range in ranges {
+        if num >= range.0 && num <= range.1 {
+            return true;
+        }
+    }
+    false
+}
+pub fn parse_range_input(s: &str) -> Result<Vec<(usize, usize)>, String> {
+    let mut ranges = Vec::new();
+    let parts = s.split(",").collect::<Vec<_>>();
+    for part in parts {
+        if part.is_empty() {
+            continue;
+        }
+        if part.starts_with(">") {
+            let num = part[1..].parse::<usize>();
+            match num {
+                Ok(num) => ranges.push((num, usize::MAX)),
+                Err(_) => return Err("Invalid range".to_string()),
+            }
+        } else if part.starts_with("<") {
+            let num = part[1..].parse::<usize>();
+            match num {
+                Ok(num) => ranges.push((0, num)),
+                Err(_) => return Err("Invalid range".to_string()),
+            }
+        } else {
+            let part = part.trim();
+            let parts = part.split("-").collect::<Vec<_>>();
+            if parts.len() == 1 {
+                let num = parts[0].parse::<usize>();
+                match num {
+                    Ok(num) => ranges.push((num, num)),
+                    Err(_) => return Err("Invalid range".to_string()),
+                }
+            } else if parts.len() == 2 {
+                let num1 = parts[0].parse::<usize>();
+                let num2 = parts[1].parse::<usize>();
+                match (num1, num2) {
+                    (Ok(num1), Ok(num2)) => ranges.push((num1, num2)),
+                    _ => return Err("Invalid range".to_string()),
+                }
+            } else {
+                return Err("Invalid range".to_string());
+            }
+        }
+    }
+    Ok(ranges)
+}