# yauaa parses the user agent string into attributes you can query

> Yauaa is a Java library that takes a user agent string, and the client hints that sometimes come with it, and pulls as many structured attributes out of it as it can, such as the device, the operating system, the browser and the engine. What makes it useful beyond a demo is the layer of user defined functions on top, so the same parser can be dropped into Beam, Flink, Hive, NiFi, Snowflake, Snowplow and Trino without rewriting it in each of them.

**nielsbasjes/yauaa** — Yet Another UserAgent Analyzer

- Repository: https://github.com/nielsbasjes/yauaa
- Website: https://yauaa.basjes.nl
- Stars: 955 · Forks: 145
- Language: Java
- License: Apache-2.0
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/nielsbasjes-yauaa

## A user agent string treated as a data source

The description is that this is a Java library which tries to parse and analyze the user agent string, and the User-Agent Client Hints when they are available, and extract as many relevant attributes as possible. The word tries is doing some work, because a user agent string is a free text field that vendors write for their own purposes, and there is no standard that says what goes in it. The library's answer is a set of heuristics per vendor and per device family, and the value of the project is the years of those heuristics. It works with Java, Scala and Kotlin, and the result is a bag of attributes rather than a string, which is the difference between a field you can group by in a warehouse and a field you have to parse again downstream. The project is Apache-2.0 licensed, published to Maven Central under the `nl.basjes.parse.useragent` namespace, and its website is at yauaa.basjes.nl.

## Client hints are the part that changes the job

Most of the work in user agent analysis is the legacy string, and the newer part of the job is the client hints, where the browser tells you a small set of facts about itself in structured form instead of in a string you have to guess at. A library that handles both is more useful than one that handles only the string, because the two arrive together and a pipeline usually has both. The extraction is not a fixed list, the stated goal is as many relevant attributes as possible, which in practice means the device class, the operating system and its version, the browser and its version, the rendering engine, and the hardware bits that can be derived from the model string. The directory layout reinforces the point, with an `analyzer/` module for the parsing itself, a `benchmarks/` directory for measuring it, a `udfs/` directory for the engine integrations and a `webapp/` for the web front end.

## The UDFs are why a data engineer would pick it

The feature that separates yauaa from a parsing library is the layer of ready to use user defined functions for several processing systems, and the topic list enumerates them, with Apache Beam, Apache Flink, Apache Hive, NiFi processors, Snowflake, Snowplow and a Trino plugin. The value is the same in each case. A team that needs device dimensions in a Trino query or a Hive table does not want to keep a Java library on the classpath of a query engine, and a UDF moves the parsing into the engine's own execution model. It also means the parsing logic is written once, in the analyzer module, rather than reimplemented in Python, Scala and SQL for each system. The `udfs/` directory in the tree is where those integrations live, and the `examples/` directory carries a GraalVM native build example, which is the other way people run this kind of parser in a container.

## Three ways to run it, one of which is a trial

The documentation points at a site where you can try it in your own browser, and the readme attaches two notes to it, that it runs on a very slow and rate limited machine, and that if you really like it you should run it on your own systems because it is much faster that way. The third option is a container, and a Kubernetes ready Docker image is provided, with a documentation page for the WebServlet that explains how to embed the parser in a web application. The deployment scripts in the tree, `start-docker.sh` and `deploy-snapshot.sh`, suggest the intended workflows, and the Docker image is published as `nielsbasjes/yauaa` on Docker Hub. The trial service exists so that you can paste a user agent string and see the attributes without installing anything, and the readme is honest that it is not where you should send your production traffic.

## Reproducible builds and a benchmark directory

Two details in the repository speak to how the project is run. The first is the reproducible builds badge, which comes from a service that rebuilds the published Maven artefacts and checks that the result matches what is in the repository, and for a library that is on the classpath of a great many pipelines that is a real property rather than a nicety. The second is the `benchmarks/` directory, which is a reminder that a parser is a hot path in a log processing job, where a request is parsed once per request across millions of rows. The coverage badge and the release guide in the tree, with a `release.sh` and a Maven wrapper, round out a project with a proper release process rather than a set of manual steps.

## Ten years of tuning, and what the author asks for

The licence section is the most personal part of the readme and it is worth quoting the substance rather than the tone. The author publishes under Apache 2.0 because he believes it is the best way to make this kind of project available to the world, and then says not to underestimate how much work went into it, that he has spent over a decade tuning the project to what it is now. What he wants in return is a little gratitude, and for the small cases that is a star on the project, and for a company whose products use the code he would rather have a small sponsorship, and the more useful contributions he names are bug reports, headers from real or new devices and browsers he has not seen before, and discussions about what could be done better. The copyright runs from 2013 to 2026, and the SECURITY file, the changelog and the renovate configuration in the tree are the practical shape of an actively maintained library.

## What to check before you wire it into a pipeline

Three things. The first is which integrations you actually need, since the UDF set is the reason to choose the library and it is enumerated per engine, so a project on an engine without a UDF will be running the analyzer module directly inside a user defined function of its own, which is more work than the library saves. The second is the version and its cadence, with 8.2.0 published on 2026-07-24, 8.1.1 in March 2026 and 8.1.0 in February 2026, so the major line moves and the minor line is where the churn is. The third is the licensing and the use you have in mind, since Apache 2.0 still requires keeping the copyright and licence notices, but the project carries a request for sponsorship, and the author draws the line at whether the code adds real business value. The tree also contains a `.gitlab-ci.yml` alongside the GitHub Actions workflow, which is a small sign of a project that has been built and released through two different systems over its life.

## Conclusion

yauaa suits a data engineer who needs device and browser fields in a warehouse and does not want to keep a regex library alive in every pipeline, and it suits a Java shop that wants one parser shared between a web application and a batch job. It is a poor fit if you need the parser to be fast above all else, since the author describes a decade of tuning rather than a minimal implementation, and it is a poor fit if you intend to feed it untrusted user agent strings from the internet at volume without reading the operational notes, because the online trial service is rate limited and slow for a reason. Before you adopt it, check three things: which of the UDFs you need exist for your engine, since that is what the topic list enumerates, the deployment route, because the Docker image is Kubernetes ready and the online trial is explicitly not meant for real use, and the version, with 8.2.0 published on 2026-07-24 and the last push to the repository on 2026-10-19.

## FAQ

### What does yauaa do?

It is a Java library that parses and analyzes the user agent string, and the User-Agent Client Hints when they are available, and extracts as many relevant attributes as possible. It works with Java, Scala and Kotlin, and the documentation is at yauaa.basjes.nl.

### Which data processing systems does yauaa support?

It ships ready to use user defined functions for several of them, with the project topics naming Apache Beam, Apache Flink, Apache Hive, NiFi processors, Snowflake, Snowplow and a Trino plugin. The parsing itself lives in the analyzer module and the integrations in the udfs directory.

### How can I try yauaa?

There is an online trial at try.yauaa.basjes.nl, but the readme notes that it runs on a very slow and rate limited machine and that you should run it locally if you like it, because it is much faster that way. A Kubernetes ready Docker image is provided as nielsbasjes/yauaa, along with a web application and a GraalVM native example.

### What licence is yauaa under?

Apache 2.0, published on Maven Central under the nl.basjes.parse.useragent namespace. The author says he chose it because it is the best way to make such projects available, and asks for sponsorship rather than obligation, while asking for bug reports and headers from new devices as the most useful contributions.

### Is yauaa still maintained?

Yes, with version 8.2.0 published on 2026-07-24 after 8.1.1 in March 2026 and 8.1.0 in February 2026, and the last push to the repository on 2026-10-19. The project also carries a reproducible builds badge, a coverage badge and a benchmarks directory, and the copyright runs from 2013 to 2026.

## Sources

- [License: Apache-2.0](https://github.com/nielsbasjes/yauaa/blob/main/LICENSE)
- [nielsbasjes/yauaa on GitHub](https://github.com/nielsbasjes/yauaa)
- [Project website](https://yauaa.basjes.nl)
- [README](https://github.com/nielsbasjes/yauaa/blob/main/README.md)
- [Releases](https://github.com/nielsbasjes/yauaa/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/nielsbasjes-yauaa