Blog

Copy, paste, caught: Catch data leaks in emails and GenAI prompts with text fingerprinting

One Elasticsearch query finds the patent paragraph someone pasted into a GenAI prompt and highlights the copied words on both sides, so a reviewer can see in seconds what left the company.

Elasticsearch is packed with new features to help you build the best search solutions for your use case. Learn how to put them into action in our hands-on webinar on building a modern Search AI experience. You can also start a free cloud trial or try Elastic on your local machine now.

Figure 1: An outgoing email with a copied paragraph highlighted, next to the protected filing it came from. The demo that accompanies this post produced it; the names and the email are fictitious.

An engineer pastes three sentences from an unreleased patent filing into an email to a supplier or into a generative AI (GenAI) chat to polish the wording. Nothing in the message is labeled confidential, and the rest of it’s ordinary. Could you find those three sentences in the message and show which words came from which protected document? Using a technique called text fingerprinting, Elasticsearch can catch this kind of data leakage with the text analysis that it already includes. Figure 1 shows the result, with the copied words highlighted in the email and in the protected filing.

Leaks are one use of a more general ability to find copied text. Text fingerprinting answers two questions about any text, and both questions run on the same index: 

  • The first is matching (or copy detection): Does this text contain a passage copied from a document I know? And Which passage? That covers leaks, plagiarism, and near-duplicate documents, as well as finding where a contract clause or a known memo turns up in a large collection during legal discovery or a law enforcement investigation. 

  • The second is classification: Which known template or boilerplate does this text share? A shared disclaimer can identify the sender, and a shared phishing template can link thousands of messages to one campaign. 

If you already use Elasticsearch, here’s the short version. You can index your protected documents with an analyzer that cuts text into overlapping eight-word phrases and check new text with a plain match query. The following is simplified from the demo's mappings/index.json and check.py:

PUT protected-docs
{
  "settings": {
    "analysis": {
      "filter": {
        "shingle_8": {"type": "shingle", "min_shingle_size": 8, "max_shingle_size": 8, "output_unigrams": false}
      },
      "analyzer": {
        "fingerprint_8": {"type": "custom", "tokenizer": "standard", "filter": ["lowercase", "asciifolding", "shingle_8"]}
      }
    }
  },
  "mappings": {
    "properties": {
      "body": {"type": "text", "analyzer": "fingerprint_8", "index_options": "offsets", "norms": false}
    }
  }
}


GET protected-docs/_search
{
  "query": {"match": {"body": {"query": "<the whole outgoing email>"}}},
  "highlight": {"fields": {"body": {"type": "unified", "number_of_fragments": 0}}}
}

If you prefer Elasticsearch Query Language (ES|QL), the same check is a MATCH function. Its options include minimum_should_match, which is the number of shared phrases that you require. (See Match rule: How many shared phrases count as a copy.) Pass the message as the ?email query parameter from your client:

FROM protected-docs METADATA _score
| WHERE MATCH(body, ?email, {"minimum_should_match": 3})
| SORT _score DESC
| KEEP title, _score
| LIMIT 10

In this post, we explain how it works, which controls you have, what you can use it for, and how to try it with the demo.

How does text fingerprinting work?

Text fingerprinting is a copy-detection technique. It cuts a document into overlapping phrases of a fixed number of words and indexes every one, so any text that shares those phrases traces back to the document it came from. It works in three steps:

1. Normalize the text. Whitespace and punctuation can easily change between versions of a document, as can capitalization, so they shouldn't affect the matching.

2. Cut the text into overlapping phrases of a fixed number of words (eight in this post). Here’s the start of a sentence from Figure 1:

a few drops of immersion fluid usually oil are applied ...

→ "a few drops of immersion fluid usually oil"

→ "few drops of immersion fluid usually oil are"

→ "drops of immersion fluid usually oil are applied"

Each phrase is one part of the document's fingerprint. An eight-word phrase is specific enough that two unrelated texts rarely share one by chance, so a single shared phrase is a lead, and several in a row are good evidence of copying.

3. Look for the same phrases in the new text. Two texts that share a passage share the phrases inside it, wherever the passage sits in either text, so a three-sentence quote inside a long email matches as well as the same three sentences on their own.

Small edits break only the phrases that contain them. If someone changes one word in a 20-word passage, up to eight phrases that include that word stop matching, and the phrases on either side still match:

Figure 2: An edit breaks only the phrases that contain it.

Think of a page torn out of a book. You can find the book it came from by looking for runs of identical words, even if a few words on the page are smudged. Topic and style won't help much because many books cover the same subject, so identical runs of words are what point to the source.

How to build text fingerprinting in Elasticsearch

Elasticsearch has the building blocks. Its analyzers turn text into the terms that the index stores and that queries look up, so a custom analyzer can produce the phrases directly, both when documents are indexed and when a message is checked.

Index the protected documents with a shingle analyzer

The standard tokenizer splits text into words and drops punctuation, and the lowercase and asciifolding filters remove differences in case and accents, so "Immersion fluid, usually oil" and "immersion fluid usually Oil" produce the same phrases. The shingle token filter then joins every eight consecutive words into one term. The demo's mappings/index.json defines two analyzers from these parts: fingerprint_8 for indexing, and fingerprint_8_search for queries, which adds a stop list for boilerplate:

{
  "settings": {
    "analysis": {
      "filter": {
        "shingle_8": {
          "type": "shingle",
          "min_shingle_size": 8,
          "max_shingle_size": 8,
          "output_unigrams": false
        },
        "boilerplate_stop": {
          "type": "stop",
          "stopwords": "_none_"
        }
      },
      "analyzer": {
        "fingerprint_8": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": ["lowercase", "asciifolding", "shingle_8"]
        },
        "fingerprint_8_search": {
          "type": "custom",
          "tokenizer": "standard",
          "filter": ["lowercase", "asciifolding", "shingle_8", "boilerplate_stop"]
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "body": {
        "type": "text",
        "analyzer": "fingerprint_8",
        "search_analyzer": "fingerprint_8_search",
        "index_options": "offsets",
        "norms": false
      }
    }
  }
}

Two field options matter. index_options: offsets stores the character position of every phrase, which lets the highlighter show the copied words. And norms: false stops document length from affecting the score, because a short passage copied into a long document is as much a copy as one pasted into a short document.

Figure 3: The same phrase-building analyzer processes the protected documents when they’re indexed and the message when it’s checked.

Check a message with one match query

A check sends the whole message in a match query. The search analyzer cuts the message into the same phrases, and the protected documents that share at least one of them come back, with the strongest match first:

GET protected-docs/_search
{
  "query": {"match": {"body": {"query": "<the whole message>"}}}
}

To ask for more evidence, minimum_should_match raises the bar from one shared phrase to at least that many:

GET protected-docs/_search
{
  "query": {"match": {"body": {"query": "<the whole message>", "minimum_should_match": 3}}}
}

If the message repeats a phrase, the query counts it each time, so before you raise an alert, count the distinct phrases that each returned document shares with the message, and find the longest unbroken copied run. The match query returns the documents and the highlights; counting distinct phrases and finding the longest run take a little client code on top of the analyze API, as in the demo's check.py. The search returns only a few documents, so this check adds little work.

Show the copied words with the unified highlighter

For each matched document, the unified highlighter returns the protected text with every shared phrase marked. Add a highlight block to the same search; with number_of_fragments set to 0, it returns the whole field rather than short snippets:

GET protected-docs/_search
{
  "query": {"match": {"body": {"query": "<the whole message>", "minimum_should_match": 3}}},
  "highlight": {
    "fields": {"body": {"type": "unified", "number_of_fragments": 0}}
  }
}

The highlighter uses the offsets stored in the index to mark the copied words in each matched document. For the email in Figure 1, the response contains (shortened here):

"highlight": {
  "body": ["... introduced between the magnifying glass device and the surface of the skin. <em>A few drops of immersion fluid, usually oil, are applied between the glass surface and the skin surface</em>. This technique reduces the amount of light ..."]
}

To mark the same words in the message, run the message through the same analyzer with the analyze API, which returns each phrase with its character offsets. That evidence on both sides, as in Figure 1, is what lets a reviewer decide quickly.

Use stop words to ignore boilerplate phrases

Some phrases occur in many documents for reasons that have nothing to do with copying. These include disclaimers, signatures, standard headings, and stock expressions, such as "it should be understood that there is no…" In a leak check, they cause false alarms, because an email that shares a footer with a protected document hasn't leaked anything.

Elasticsearch can ignore terms at query time with the stop token filter. It’s usually used for single words, such as "the" and "and," but it works on whole eight-word phrases, too. Put it at the end of the search analyzer only, as fingerprint_8_search does in the mapping above. The index keeps every phrase, so the same documents still support classification, and leak checks never ask for the listed phrases.

To build the list, find the phrases that occur in many documents. Take a random sample of documents, and read their stored phrases with the multiple term vectors API. Then count how many sampled documents contain each one. The demo's boilerplate.py does this in a short script. Take the most frequent phrases as candidates, and count them exactly across the whole index with one filters aggregation:

GET protected-docs/_search
{
  "size": 0,
  "aggs": {
    "common": {
      "filters": {
        "filters": {
          "of the invention the present invention relates to": {"term": {"body": "of the invention the present invention relates to"}},
          "brief description of the drawings fig 1 is": {"term": {"body": "brief description of the drawings fig 1 is"}}
        }
      }
    }
  }
}

Each bucket's doc_count is the number of documents that contain the phrase. In the demo's 2,000 patents, the most common one, "of the invention the present invention relates to," appears in 295. Phrases that occur in more documents than your chosen threshold go into the stop list. Add your own boilerplate, as well, such as your email footers and disclaimers, because those are the phrases that your traffic shares with your documents.

"boilerplate_stop": {
  "type": "stop",
  "stopwords": [
    "of the invention the present invention relates to",
    "brief description of the drawings fig 1 is"
  ]
}

Then apply it in one of two ways, depending on whether you still need the boilerplate for classification:

  • Search analyzer only. Update the list on the existing index. The index keeps every phrase, so the classification query below still works. The demo's Apply button does this.

  • Index analyzer, too. Add the filter to the index analyzer, create a new index, copy the documents across with the reindex API, and point your checks at it; for example, by moving an alias. The listed phrases aren’t indexed anymore, so the index is smaller, but you can no longer count boilerplate for classification.

In our test, a check containing only the most common phrase matched 295 documents before the list was applied (and none after), while the same check with the index analyzer still matched all 295. In practice, build and review the list on a nonproduction copy of your data, and then create the production index with it. We tested lists of a few hundred phrases. Review the list when your templates or footers change, because a phrase on the list can no longer find a match.

For classification, where boilerplate is the signal, query the same index with the index analyzer, so the stop list doesn't apply:

{"match": {"body": {"query": "<the message>", "analyzer": "fingerprint_8"}}}

Tune text fingerprinting: Phrase length and match rules

Two controls decide what counts as a match: the phrase length and the match rule. (The stop list is covered in Use stop words to ignore boilerplate phrases .) Each trades how much copying you catch against how many false alarms you get.

Phrase length: 5, 8, or 12 words

The phrase length is the min_shingle_size and max_shingle_size pair in the analyzer:

  • Shorter phrases, around five words, find shorter copies and survive heavier editing, but ordinary phrases match by chance more often, so pair them with a stricter match rule.

  • For this demo, eight words worked well and is a sensible starting point, but it's worth tuning the length for your use case.

  • Longer phrases, around 12 words, match by chance less often, but they need longer unedited runs.

The phrase length is part of the index analyzer, so changing it means reindexing. Try two or three lengths on a sample of your own documents and traffic before you settle on one.

Match rule: How many shared phrases count as a copy

The match rule is the control that you’ll tune most often:

Rule

What it catches

What it costs

Any shared phrase

Short and lightly edited copies

Stock phrases trigger it, and false alarms grow with the protected set

At least three shared phrases

Copies of 20 words or more, including lightly edited ones

Far fewer false alarms than "any"

5–10 shared phrases

Longer copies

Misses short copies with edits

An unbroken copied run of 16 words or more

Exact copies of a passage

Any edit inside the run breaks it

For leak detection, two tiers work well. A permissive rule, such as at least three shared phrases, feeds a review queue and catches edited copies. A strict rule, such as an unbroken copied run of 16 words, raises high-confidence alerts for exact copies that need little review. As a sanity check, we ran real emails from the Enron Email Dataset against up to 174,000 patents; the "at least three" rule found every patent passage we inserted, including ones with a word changed every 12 or so, and flagged about 1.2 emails in 1,000 that copied nothing. At 100,000 messages a day, that would still mean about 120 reviews, so measure with your own data before choosing a rule.

Text fingerprinting tolerates edits and keeps false alarms low. It also shows which document a match came from and which words were copied.

Use case

The questions

What you index

A starting point

Data leakage in email, chat, and GenAI prompts

Did protected text leave? Which words?

Your protected documents

Eight-word phrases, at least three shared, plus a 16-word run for high-confidence alerts

Plagiarism and near-duplicates, including deduplication before retrieval augmented generation (RAG)

Was this passage reused? From where?

The source documents or the collection itself

Shorter phrases with a stricter match rule

Legal discovery and investigations

Where else does this known document or clause appear?

The collection under review

Eight-word phrases, one search per known passage

Templates and classification, such as phishing

Which known template does this text share?

Known templates and boilerplate

Count boilerplate with the index analyzer

  • Data leakage. In industries that rely on intellectual property, security and insider-risk teams need to know when protected text leaves through email, chat, or tickets, and via prompts pasted into GenAI tools. The protected set might be patent drafts, contracts, source documents, or board papers. Elasticsearch does the matching. The text has to reach it first; for example, from a mail gateway's journal or from the logs of a proxy in front of GenAI tools. Data loss prevention (DLP) products cover channels and endpoint agents, as well as enforcement, and fingerprinting adds passage-level evidence from your own documents to that workflow.

  • Plagiarism and near duplicate detection. If you wanted to check if submitted work such as document contains other work without referencing it you could easily detect referenced work such as text books or previously submitted work. 

  • Legal and investigative collections. Imagine you hold a set of documents that exposes a crime or proves your case. You need to know who else had a copy (or part of one), but what you have is hard drive images with thousands or millions of emails and documents in different formats. Fingerprinting scans that volume for partial matches, one search per known passage, and many passages can run together with the multiple search API. A match is a run of identical words, with no model involved, so you can show a reviewer exactly why it fired. The text has to be extracted first, which for scanned documents means optical character recognition (OCR).

  • Templates and classification. Boilerplate is noise when you look for leaks and the signal when you want to classify text. Imagine a new email comes in and shares several phrases that occur often in your phishing index but rarely in your normal email. The fingerprints act as a classifier. They can't tell you that a message is definitely phishing, but they flag it for review without the false alarms of alerting on single phrases.

Watch recent messages for known text

Most of these checks take one message and search many protected documents. You can also turn it around; that is, index your messages with the same analyzer and run one known text against the most recent ones on a schedule. This suits a small set of high-value texts, such as a phishing template that’s circulating or a leaked paragraph that you want to trace. It also applies to a disclaimer that should never leave the company.

GET messages/_search
{
  "query": {
    "bool": {
      "must": [{"match": {"body": {"query": "<the known text>", "minimum_should_match": 3}}}],
      "filter": [{"range": {"@timestamp": {"gte": "now-15m"}}}]
    }
  },
  "highlight": {"fields": {"body": {"type": "unified", "number_of_fragments": 0}}}
}

In a test on Elastic Cloud Serverless (Serverless), this returned the email that quoted a phishing template in the last 15 minutes, with the copied words highlighted, and ignored the same template sent five hours earlier and an unrelated email. A Kibana Elasticsearch query rule can run the match part on a schedule and apply its own time window on @timestamp. And it can alert when messages match. We tested the query, and the rule setup is a starting point to adapt. This pattern detects a message after it has gone; blocking needs an enforcement point, such as a mail gateway that runs the check first.

Guard GenAI prompts in regulated industries

Banks, insurers, pharmaceutical companies, and law firms want their teams to use frontier models, but they also need to control what leaves the organization and prove to an auditor that they’re doing so. A prompt is another outgoing message, so the same check can sit in front of the model.

Check GenAI prompts before they leave the company

Put a proxy between your users' chat tools and the model provider. For each request, the proxy sends the user's text to Elasticsearch in the same match query and forwards the request only when no protected document matches. Block on a match rule that you trust, such as ″at least three shared phrases after a boilerplate″ stop list, and log weaker matches for review. Check the text of every message, because the client sends the whole history with each request. We recommend blocking the request if the check itself fails.

The demo includes a small proxy, proxy.py, a sketch rather than a production gateway, that does this behind an OpenAI-style chat endpoint and forwards allowed prompts to a model through the Elasticsearch Inference API. 

On the demo data, with at least three shared phrases as the rule:

  • Ninety-nine to 100% of prompts containing a copied passage of 20–80 words were flagged, including lightly edited ones.

  • None of 200 ordinary emails were flagged.

  • Twelve percent of patent text that wasn’t in the index was flagged, mostly on stock phrases, which is why boilerplate-heavy collections need a stop list.

It doesn't catch a passage that someone (or another model) has reworded first. That’s the limit of copy detection, so pair it with other controls. The check adds a few requests to Elasticsearch for each prompt, so run the blocking cluster close to the proxy to keep them fast.

Combine fingerprinting with percolator rules for known terms

Fingerprints catch copied passages. Many policies are about known terms instead, like project code names or customer names, or the format of an account number. The percolator stores those rules as queries and checks each message against all of them in one request. Run both checks on the same message in the same cluster, and the proxy gets one decision with the evidence from each.

Keep an audit trail of prompts and decisions

Regulators (sometimes years later) ask what was sent and by whom, along with what was blocked. Elasticsearch is a good long-term store for that record. Write each prompt, response, decision, and matched document to a data stream, and keep recent data on fast storage. Move older data to cheaper tiers with index lifecycle management (on Serverless, data stream lifecycle handles retention), and analyze it with ES|QL and Kibana dashboards. Give the two jobs separate clusters:

  • A blocking cluster holds the protected documents and answers the proxy in real time. It stays small and is tuned for low latency.

  • An audit cluster holds the chat history for as long as you need to keep it. It’s tuned for retention and analytics, and access to it is tightly restricted, because it contains the very text that you’re protecting.

The proxy can write the audit records itself, or you can send them with OpenTelemetry (OTel). Some large language model (LLM) gateways and SDKs can export GenAI telemetry natively, and Elastic accepts it over the OpenTelemetry Protocol (OTLP), through the managed OTLP endpoint on Elastic Cloud or an Elastic Distribution of OpenTelemetry (EDOT) Collector when self-managed. Recording prompt and response content in OTel is usually opt-in, so turn it on deliberately.

Why text fingerprinting scales in Elasticsearch

The inverted index in Elasticsearch is built to answer one question quickly: Which documents contain this term? Fingerprinting turns copy detection into exactly that question, with eight-word phrases as the terms. A check is one search, so you can expect it to scale the way that your other searches do, with shards and replicas on self-managed Elasticsearch or Elastic Cloud Hosted (ECH), and through autoscaling on Serverless. 

Three things grow with your data:

  • The index grows with the protected text. Every word position starts a new phrase, and each is stored with its offsets, so the index is several times the size of the raw text. Ours was about four to five times on 174,000 patents after a force merge, including the stored source. A small or unmerged index can be larger, so measure on your own data.

  • Each query has one clause per phrase in the incoming message, so a long message costs more to check than a short one. Very long messages can reach the limit on clauses in one query, which Elasticsearch derives from each node's heap size and search thread pool.

  • The chance of a false alarm grows with the size of the protected set, because more documents means more ordinary phrases to share by chance. The match rule keeps this in check.

On a single laptop node, query time didn't change noticeably as the protected set grew from 1,000 to 174,000 patents, and Serverless found the same false alarms.

Costs to run: Storage, tuning, and index security

Plan for the following ongoing costs:

  • Storage of several times the size of the protected text.

  • One mapping and one query to start, and then a match rule and a stop list to tune, plus someone who owns both and reviews the alerts.

  • Protection for the protected index itself. It contains your sensitive text, so secure it as you would the source. Restrict who can read it, including its term vectors, and include it in your backup policy.

How text fingerprinting compares to semantic search and file hashing

Fingerprinting and semantic search answer different questions. Fingerprinting finds the same words, which is what you need as evidence of copying. And semantic search finds text about the same concept, which is what most search experiences need. 

File hashing is the third option, and the three differ on what they find and what they can show you:

Text fingerprinting

Semantic search

File hashes (MD5)

Finds

Identical word runs

Similar meaning

Identical files

Survives edits

Yes, partially

Yes

No

Finds reworded text

No

Yes

No

Threshold to tune

Shared phrases or run length

Similarity score

None

Shows evidence

The copied words, highlighted

A score

File match only

False alarms on topic overlap

Low

High

None

The difference matters most for false alarms. In semantic search, every document is similar to a query, to some degree, so a check always returns something, and the hard part is choosing a similarity threshold. Set it low, and every email about the same topic as a patent becomes an alert; set it high, and short copied passages slip through, because a three-sentence quote barely changes the meaning of a long email. Fingerprinting gives you a threshold that you can reason about and explain, like a number of shared phrases or a run of copied words, which a reviewer can see highlighted.

Semantic search is the right tool when text has been reworded or summarized, or when it has been translated, because those texts share meaning and few exact phrases. The two techniques complement each other, and hybrid search can combine them; for example, with fingerprints for evidence of copying and semantic search for leads on paraphrased content.

What text fingerprinting cannot detect

Fingerprinting finds copied and lightly edited text. It doesn’t find text that has been heavily reworded or summarized, and it doesn’t find text that has been translated. Text shorter than the phrase length produces no phrases at all, so it can never match.

Someone who knows about the check can work around it. Each of the following scenarios reduces or removes the shared phrases:

  • Replacing a word every few words.

  • Splitting a passage across several messages.

  • Swapping letters for look-alike characters from other alphabets.

  • Sending the text as an image or an attachment that isn't extracted.

Fingerprinting is a good check for the common case of copy and paste, so combine it with other controls if deliberate evasion is a concern.

There are practical limits on message length, too, including: 

  • Analyze API token limit. Ten thousand tokens per request by default, which is why the demo checks messages of up to about 9,000 words.

  • Query clause limit. Each check has one clause per phrase in the message, so a very long message can exceed the limit that Elasticsearch derives from the node’s heap size and search thread pool.

  • Heap size. On a 1 GB heap, messages of about 4,000 words failed, while 2,000 words worked, and an 8 GB heap handled them.

Our tests used one shard on a single node and one Serverless project, up to 174,000 documents, and patents against emails. Treat the scaling results as a sign that the approach holds up, not as a sizing guide.

Try the demo

The demo that accompanies this post is a small Python app with a web interface. It loads 2,000 patent descriptions and eight fictional phishing templates into an index with the mapping shown earlier. It lets you paste any text to see which protected documents it copies from, with the copied words highlighted on both sides.

Figure 4: The demo shows the copied words on both sides and the number of shared phrases, in addition to the longest copied run.

Running it is the quickest way to get a feel for the controls. Try the example emails, and edit a copied passage word by word and watch the match weaken. Switch between match rules, and use the Common phrases tab to find boilerplate and apply it as a stop list. You can also load a folder of your own text files and check emails against them.

The code is in the elasticsearch-labs repository, and its README has the full setup steps.

What you need to run the demo

  • Elasticsearch 9.x, self-managed or on Elastic Cloud. We tested on Elastic Cloud Serverless and on Elasticsearch 9.5 and 9.6. An Elastic Cloud trial works.

  • Python 3.10 or later.

  • An API key that can create and manage the demo index.

  • The sample data comes from BigPatent (Sharma, Li, and Wang, ACL 2019, licensed CC BY 4.0), which the loader downloads.

Where to start with your own documents

The three sentences pasted into an email at the start of this post share eight-word phrases with the filing they came from, and Elasticsearch finds those phrases with the analyzer and query it already has. The phrase length, match rule, and stop list decide how much evidence counts as a copy, and the highlighted words let a person check every result. For a good first experiment, load 20 of your own nonsensitive documents into the demo, and paste in a few emails that quote them. Then see which rule you would trust. Tell us what you find on Elasticsearch Discuss.

How helpful was this content?

Related Content

Too much of a good thing: Why 20 candidates beat 200 when reranking search results

Too much of a good thing: Why 20 candidates beat 200 when reranking search results

Scott Martens
Using Jev as a search reranker: benchmarks and how to implement

Using Jev as a search reranker: benchmarks and how to implement

Dustin Coates
Search relevance from click streams: Using Learn To Rank and behavioral signals with OpenTelemetry

Search relevance from click streams: Using Learn To Rank and behavioral signals with OpenTelemetry

Matthew Adams
From search to checkout in 20 lines of code: building a 4-stage conversion funnel with OpenTelemetry

From search to checkout in 20 lines of code: building a 4-stage conversion funnel with OpenTelemetry

Matthew Adams
15 lines of click tracking code that tell you what search logs can't

15 lines of click tracking code that tell you what search logs can't

Matthew Adams

Ready to build state of the art search experiences?

Sufficiently advanced search isn’t achieved with the efforts of one. Elasticsearch is powered by data scientists, ML ops, engineers, and many more who are just as passionate about search as you are. Let’s connect and work together to build the magical search experience that will get you the results you want.