Elasticsearch Elasticsearch Regex Query: Advanced Usage and Optimization

By Opster Team

Updated: Jun 22, 2023

| 2 min read


Regular expressions (regex) are a powerful way to search and filter text data. Elasticsearch, being a full-text search engine, provides support for regex queries to help users perform advanced text searches. In this article, we will discuss the usage of regex queries in Elasticsearch, their performance implications, and how to optimize them for better search performance. If you want to learn about can only use regexp queries on keyword and text fields – not on – how to solve this Elasticsearch error, check out this guide. 

Using Regex Queries in Elasticsearch

Elasticsearch supports regex queries through the `regexp` query. The `regexp` query allows you to define a regular expression pattern that Elasticsearch will use to match documents in the index. Here’s an example of a simple `regexp` query:

GET /my_index/_search
  "query": {
    "regexp": {
      "my_field": {
        "value": "elasti.*"

In this example, the query searches for documents in the `my_index` index where the `my_field` field contains a value that matches the regular expression `elasti.*`. The `.*` part of the regex pattern indicates that any character can appear zero or more times after the string “elasti”.

Using Flags to Modify Regex Behavior

You can use flags to modify the behavior of your regex patterns. Elasticsearch supports the following flags:

– `ALL`: Enables all flags.
– `ANYSTRING`: Allows any string to match the pattern.
– `COMPLEMENT`: Inverts the pattern.
– `EMPTY`: Allows empty strings to match the pattern.
– `INTERSECTION`: Allows the intersection of multiple patterns.
– `INTERVAL`: Specifies a maximum number of allowed intervals.
– `NONE`: Disables all flags.

Here’s an example of using flags in a `regexp` query:

GET /my_index/_search
  "query": {
    "regexp": {
      "my_field": {
        "value": "elasti.*",
        "flags": "COMPLEMENT"

In this example, the query will return documents where the `my_field` value does not match the regex pattern `elasti.*`.

Performance Implications of Regex Queries

While regex queries can be very powerful, they can also be resource-intensive and slow down search performance. This is because Elasticsearch needs to evaluate the regular expression against every term in the index, which can be time-consuming, especially for large indices with a high number of unique terms.

To mitigate the performance impact of regex queries, Elasticsearch applies some optimizations, such as:

1. Automatically rewriting the regex query to a more efficient form if possible.

2. Limiting the number of automaton states allowed in the regex query to prevent overly complex regular expressions from consuming too many resources.

However, these optimizations may not always be sufficient to ensure good performance. Therefore, it’s essential to follow best practices when using regex queries in Elasticsearch.

Optimizing Elasticsearch Regex Queries

Here are some tips to optimize regex queries in Elasticsearch:

1. Be specific with your regex patterns: Avoid using overly broad regex patterns that match a large number of terms. Instead, try to make your regex patterns as specific as possible to reduce the number of terms that Elasticsearch needs to evaluate.

2. Use prefix queries when possible: If your regex pattern starts with a fixed string, consider using a `prefix` query instead of a `regexp` query. Prefix queries are more efficient than regex queries because they can leverage the index structure to quickly find matching terms.

3. Limit the use of wildcard characters: Wildcard characters like `.*` and `.+` can significantly increase the complexity of your regex pattern and slow down the query performance. Try to minimize the use of wildcard characters in your regex patterns.

4. Use the `rewrite` parameter: The `rewrite` parameter allows you to control how Elasticsearch rewrites the regex query internally. By default, Elasticsearch uses the `constant_score` rewrite method, which automatically chooses the best rewrite method based on the query. However, you can experiment with other rewrite methods like `constant_score_boolean`, `scoring_boolean`, and `top_terms_N` to see if they improve the query performance.

5. Monitor and adjust the `max_determinized_states` parameter: The `max_determinized_states` parameter controls the maximum number of automaton states allowed in a regex query. By default, this value is set to 10000. If you encounter an error stating that the regex query has too many states, you can try increasing this value. However, be cautious when increasing this value, as it can lead to higher memory usage and slower query performance.


In conclusion, Elasticsearch regex queries provide a powerful way to search and filter text data. However, they can also be resource-intensive and slow down search performance. By following the optimization tips discussed in this article, you can ensure that your regex queries in Elasticsearch are both efficient and effective.

How helpful was this guide?

We are sorry that this post was not useful for you!

Let us improve this post!

Tell us how we can improve this post?