In this Redis tutorial, learn how to install and setup Redis as well as commands to write, read, update, and delete data from the store using its core data structures.
Fun Fact: Redis means "REmote DIctionary Server."
Redis delivers sub-millisecond response times that enable millions of requests per second to power demanding real-time applications such as games, ad brokers, financial dashboards, and many more!
It supports basic data structures such as strings, lists, sets, sorted sets with range queries, and hashes. More advanced data structures like bitmaps, hyperloglogs, and geospatial indexes with radius queries are also supported.
Alex Stanciu, a Product Owner from the Identity Governance Team at Auth0, explains one of our use cases for Redis:
"We use Redis as a caching layer and a session store for our Slack Bot conversation engine. Because it stores data in memory (RAM), it provides ultra-fast read and write speeds; responses are usually in the single-digit milliseconds."
In this Redis tutorial, we'll learn how to set up Redis in our systems and how to store data in Redis using its core and most frequently used data structures. With this foundation, in future posts we'll learn how to use Redis for caching, session storage, messaging, and real-time analytics. Let's get started!
The first thing that we need to do is install Redis. If you have it already running in your system, feel free to skip this part of the post.
The Redis documentation recommends installing Redis by compiling it from sources as Redis has no dependencies other than a working
GCC compiler and
libc. We can either download the latest Redis tarball from
redis.io, or we can use a special URL that always points to the latest stable Redis version:
Windows users: The Redis project does not officially support Windows. But, if you are running Windows 10, you can Install the Windows Subsystem for Linux to install and run Redis. When you have the Windows Subsystem for Linux up and running, please follow any steps in this post that apply to Linux (when specified) from within your Linux shell.
To compile Redis follow these simple steps:
- Create a
redisdirectory and make it the current working directory:
mkdir redis && cd redis
- Fetch the latest redis tarball:
curl -O http://download.redis.io/redis-stable.tar.gz
- Unpack the tarball:
tar xvzf redis-stable.tar.gz
- Make the unpacked
redis-stabledirectory the current working directory:
- Compile Redis:
makepackage is not installed in your system, please follow the instructions provided by the CLI to install it. In macOS, you may need to download XCode to have access to the command line tools which include
makeand a C compiler. For a fresh installation of Ubuntu, for example, you may want to run the following commands to update the package manager and install core packages:
sudo apt update sudo apt upgrade sudo apt install build-essential sudo apt-get install tcl8.5 make
tcl 8.5 or newer is needed to run the Redis test in the next step.
- Test that the build works correctly:
Once the compilation is done, the
src directory within
redis-stable is populated with different executables that are part of Redis. The Redis docs explain the functionality of each Redis exectuble:
redis-server: runs the Redis Server itself.
redis-sentinel: runs Redis Sentinel, a tool for monitoring and failover.
redis-cli: runs a command line interface utility to interact with Redis.
redis-benchmark: checks Redis performance.
redis-check-dump: used for the rare cases when there are corrupted data files.
We are going to be using the
redis-cli executable frequently. For convenience, let's copy both to a location that will let us access them system-wide. This can be done manually by running:
sudo cp src/redis-server /usr/local/bin/ sudo cp src/redis-cli /usr/local/bin/
redis-stable as the current working directory, this can also be done automatically by running the following command:
sudo make install
We need to restart our shell for these changes to take effect. Once we do that, we are ready to start running Redis.
The easiest way to start the Redis server is by running the
redis-server command. In a fresh shell window, type:
If everything is working as expected, the shell will receive as outline a giant ASCII Redis logo that shows the Redis version installed, the running mode, the
port where the server is running and it's
PID (process identification number).
_._ _.-``__ ''-._ _.-`` `. `_. ''-._ Redis 4.0.10 (00000000/0) 64 bit .-`` .-```. ```\/ _.,_ ''-._ ( ' , .-` | `, ) Running in standalone mode |`-._`-...-` __...-.``-._|'` _.-'| Port: 6379 | `-._ `._ / _.-' | PID: 22394 `-._ `-._ `-./ _.-' _.-' |`-._`-._ `-.__.-' _.-'_.-'| | `-._`-._ _.-'_.-' | http://redis.io `-._ `-._`-.__.-'_.-' _.-' |`-._`-._ `-.__.-' _.-'_.-'| | `-._`-._ _.-'_.-' | `-._ `-._`-.__.-'_.-' _.-' `-._ `-.__.-' _.-' `-._ _.-' `-.__.-'
We started Redis without any explicit configuration file; therefore, we'll be using the internal default configuration. This is acceptable for the scope of this blog post: understanding and using the basic Redis data structures.
As a first step, we always need to get the Redis server running as the CLI and other services depend on it to work.
How to Check if Redis is Working
redis-cli to send a command to it directly. To test that Redis is working properly, let's send it the
ping command. Open a new shell window and execute the following command:
If everything is working well, we should get
PONG as a reply in the shell.
When we issued
redis-cli ping, we invoked the
redis-cli executable followed by a command name,
ping. A command name and its arguments are sent to the Redis instance running on
localhost:6379 for it to be processed and send a reply.
The host and port of the instance can be changed. Use the
--help option to check all the commands that can be used with
If we run
redis-cli without any arguments, the program will start in interactive mode. Similar to the Read–Eval–Print Loop (REPL) of programming languages like Python, we can type different Redis commands in the shell and get a reply from the Redis instance. What those commands are and what they do is the core learning objective of this post!
Let start first by learning how to manipulate data in Redis using commands!
"Redis is a key-value store that let us store some data, the value, inside a key. It offers ultra-fast performance to satisfy demanding real-time applications like video games 🎮."
Write, Read, Update, and Delete Data in Redis
As we learned earlier, Redis is a key-value store that let us associate some data called a value with a key. We can later retrieve the stored data if we know the exact key that was used to store it.
In case that you haven't done so already, run the Redis CLI in interactive mode by executing the following command:
We'll know the interactive CLI is working when we see the Redis instance host and port in the shell prompt:
Once there, we are ready to issue commands.
To store a value in Redis, we can use the
SET command which has the following signature:
SET key value
In English, it reads like "set key to hold value." It's important to note that if the key already holds a value,
SET will overwrite it no matter what.
Let's look at an example. In the interactive shell type:
SET service "auth0"
Notice how, as you type, the interactive shell suggests the required and optional arguments for the Redis command.
enter to send the command. Once Redis stores
"auth0" as the value of
service, it replies with
OK, letting us know that everything went well. Thank you, Redis!
We can use the
GET command to ask Redis for the value of a key:
Let's retrieve the value of
Redis replies with
What if we ask for the value of a key that has never been set?
Redis replies with
(nil) to let us know that the key doesn't exist in memory.
In a classic API that connects to a database, we'd like to perform CRUD operations: create, read, update, and delete. We have covered how to create (write) and read data in Redis by using the
GET commands respectively. Let's cover the rest.
We can update the value of a key simply by overwriting its data as mentioned earlier.
Lets create a new key-value pair:
SET framework angular
But, we change our mind and now we want the value to be
"react". We can overwrite it like this:
SET framework react
Did Redis get it right? Let's ask for it!
Redis indeed replies with
"react". We are being a bit indecisive and now we want to set the
framework key to hold the value of
SET framework vue
If we run
GET framework again, we get
"vue". The update/overwrite works as excepted.
But, we don't want to actually set any framework for now and we need to delete that key. How do we do it? We use the
Let's run it:
Redis replies with
(integer) 1 to let us know the number of keys that were removed.
With just three commands,
DEL, we are able to comply with the four CRUD operations!
Wrapping Strings with Quotation Marks
Notice something curious: we did not have to put quotation marks around a single string value we wanted to store.
SET framework angular and
SET framework "angular" are both accepted by Redis as an operation to store the string
"angular" as the value of the key
Redis automatically wraps single string arguments in quotation marks. Since both key and value are strings, the same applies for the key name. We could have used
SET "framework" angular and it would have worked as well. However, if we plan to use more than one string as the key or value, we do need to wrap the strings in quotation marks:
SET "the frameworks" "angular vue react"
SET the frameworks "angular vue react"
(error) ERR syntax error
SET "the frameworks" angular vue react
Also replies with
(error) ERR syntax error
Finally, to retrieve the value, we must use the exact key string:
GET "the frameworks"
"angular vue react".
Redis is compassionate and lets us write data with care. Imagine that we wanted to create a
services key to hold the value
"heroku aws" but instead of typing
SET services "heroku aws", we typed
SET service "heroku aws". This last command would overwrite the current value of
service without mercy. However, Redis gives us a non-destructive version of
SETNX key value
SETNX creates a key in memory if and only if the key does not exist already (
Xists). If the key already exists, Redis replies with
0 to indicate a failure to store the key-value pair and with
1 to indicate success. Let's try out this previous scenario but using
SETNX instead of
SETNX service "heroku aws"
The reply is
(integer) 0 as we expected.
SETNX services "heroku aws"
This time, the reply is
(integer) 1. Great!
We can use
SETNX to prevent us from mutating data accidentally.
When creating a key with Redis, we can specify how long that key should stay stored in memory. Using the
EXPIRE command, we can set a timeout on a key and have the key be automatically deleted once the timeout expires:
EXPIRE key seconds
Let's create a
notification key that we want to delete after 30 seconds:
SET notification "Anomaly detected" EXPIRE notification 30
This schedules the
notification key to be deleted in 30 seconds. We could look at a clock and check after 30 seconds have elapsed if
notification is still available but we don't have to do that! Redis offers the
TTL command that tells us how many seconds a key has left before it expires and gets deleted:
It's possible that more than 30 seconds have already passed so let's try the above example again, but this time calling
TTL as soon as we execute
SET notification "Anomaly detected" EXPIRE notification 30 TTL notification
Redis replied with
(integer) 27 to me, indicating that
notification is still available for 27 more seconds. Let's wait a bit and run
This time, Redis replied with
(integer) -2. Starting with Redis 2.8,
- The timeout left in seconds.
-2if the key doesn't exist (either it has not been created or it was deleted).
-1if the key exists but has no expiry set.
I made sure that 30 seconds had passed so
-2 was expected. Let's see the error message when the key exists but has no expiry set:
SET dialog "Continue?" TTL dialog
As expected, with no expiry set, Redis replies with
It's important to note that we can reset the timeout by using
SET with the key again:
SET notification "Anomaly detected" EXPIRE notification 30 TTL notification // (integer) 27 SET notification "No anomaly detected" TTL notification // (integer) -1
We learned earlier that using
SET is the same as creating the key again, which for Redis also involves resetting any timeouts currently assigned to it.
We have a solid foundation now on manipulating data in Redis. With this knowledge under our belt, we are ready to now explore the data types that Redis offers.
Redis Data Types
Far from being a plain key-value store, Redis is an actual data structure server that supports different kinds of values. Traditionally, key-value stores allow us to map a string key to a string value and nothing else. In Redis, the string key can be mapped to more than just a simple string.
Being a data structure server, we can also refer to the data types as data structures. We can use these more complex data structures to store multiple values in a key at once. Let's look at these types at a high level. We'll explore each type in detail in subsequent sections.
- Binary-safe Strings
The most basic kind of Redis value. Being "binary-safe" means that the string can contain any type of data represented as a string: PNG images or serialized objects, for example.
In essence, Redis Lists are linked lists. They are collections of string elements that are sorted based on the order that they were inserted.
They represent collections of unique and unsorted string elements.
- Sorted Sets
Like Sets, they represent a collection of unique string elements; however, each string element is linked to a floating number value, referred to as the element score. When querying the Sorted Set, the elements are always taken sorted by their score, which enables us to consistently present a range of data from the Set.
These are maps made up of string fields linked to string values.
- Bit arrays
Also known as bitmaps. They let us handle string values as if they were an array of bits.
A probabilistic data structure used to estimate the cardinality of a set, which is a measure of the "number of elements of the set."
We have already covered Strings during the "Write, Read, Update, and Delete Data in Redis" section. For the rest of this tutorial, we are going to focus on all the Redis types except bitmaps and hyperloglogs. We'll visit those on a future post handling an advanced Redis use case.
Every time some site gets "slashdotted" and is no longer reachable, I think at my little blog in a 5$/mo VM that resists any HN top position pressure without being even remotely affected. And think that many people are sincerely missing an opportunity to use Redis.— ANTIREZ (@antirez) July 12, 2018
A List is a sequence of ordered elements. For example,
1 2 4 5 6 90 19 3 is a List of numbers. In Redis, it's important to note that Lists are implemented as linked lists. This has some important implications regarding performance. It is fast to add elements to the head and tail of the List but it's slower to search for elements within the List as we do not have indexed access to the elements (like we do in an array).
A List is created by using a Redis command that pushes data followed by a key name. There are two commands that we can use:
LPUSH. If the key doesn't exist, these commands will return a new List with the passed arguments as elements. If the key already exists or it is not a List, an error is returned.
RPUSH inserts a new element at the end of the List (at the tail):
RPUSH key value [value ...]
Let's create an
engineers key that represents a List:
RPUSH engineers "Alice" // 1 RPUSH engineers "Bob" // 2 RPUSH engineers "Carmen" // 3
Each time we insert an element, Redis replies with the length of the List after that insertion. We would expect the
users list to resemble this:
Alice Bob Carmen
How can we verify that? We can use the
LRANGE returns a subset of the List based on a specified start and stop index. Although these indexes are zero-based, they are no the same as array indexes. Given a full List, they simply indicate where to partition the List: make a slice from here (start) to here (stop):
LRANGE key start stop
To see the full List, we can use a neat trick: go from
0 to the element just before it,
LRANGE engineers 0 -1
1) "Alice" 2) "Bob" 3) "Carmen"
-1 will always represent the last element in the List.
To get the first two elements of
engineers we can issue the following command:
LRANGE engineers 0 1
LPUSH behaves the same as
RPUSH except that it inserts the element at the front of the List (at the header):
LPUSH key value [value ...]
Daniel at the front of the
LPUSH engineers "Daniel" // 4
We now have four engineers. Let's verify that the order is correct:
LRANGE engineers 0 -1
Redis replies with:
1) "Daniel" 2) "Alice" 3) "Bob" 4) "Carmen"
It's the same List we had before but with
"Daniel" as the first element, which is exactly what was expected.
Multiple Element Insertions
We saw in the signatures of
LPUSH that we can insert more than one element through each command. Let's see that in action.
Based on our existing
engineers list, let's issue this command:
RPUSH engineers "Eve" "Francis" "Gary" // 7
Since we are inserting them at the end of the List, we expect these three new elements to show up in the same order in which they are listed as arguments. Let's verify:
LRANGE engineers 0 -1
To what Redis returns:
1) "Daniel" 2) "Alice" 3) "Bob" 4) "Carmen" 5) "Eve" 6) "Francis" 7) "Gary"
What about if we do the same with
LPUSH engineers "Hugo" "Ivan" "Jess" // 10
Will Redis insert these three new elements one by one or will it insert them as a bundle, all three at once?
LRANGE 0 -1
1) "Jess" 2) "Ivan" 3) "Hugo" 4) "Daniel" 5) "Alice" 6) "Bob" 7) "Carmen" 8) "Eve" 9) "Francis" 10) "Gary"
When listing multiple arguments for
RPUSH, Redis inserts the elements one by one, thus,
"Jess" appear in the reverse order from which they were listed as arguments.
We can find the length of a List at any time by using the
Let's verify that the length of
engineers is indeed
Redis replies with
(integer) 10. Perfect.
Removing Elements from a Redis List
Similar to how we can "pop" elements in arrays, we can pop an element from the head or the tail of a Redis List.
LPOP removes and returns the first element of the List:
We can use it to remove
"Jess", the first element, from the List:
Redis indeed replies with
"Jess" to indicate it is the element that was removed.
RPOP removes and returns the last element of the List:
It's time to say goodbye to
"Gary", the last element of the List:
The reply from Redis is
It's very useful to be able to get the element that was removed from the List as we may want to do something special with it.
Redis Lists are implemented as linked lists because its engineering team envisioned that for a database system it is crucial to be able to add elements to a very long list in a very fast way.
In Redis, a Set is similar to a List except that it doesn't keep any specific order for its elements and each element must be unique.
We create a Set by using the
SADD command that adds the specified members to the key:
SADD key member [member ...]
Specified members that are already part of the Set are ignored. If the key doesn't exist, a new Set is created and the unique specified members are added. If the key already exists or it is not a Set, an error is returned.
Let's create a
SADD languages "english" // 1 SADD languages "spanish" // 1 SADD languages "french" // 1
In this case, on each member addition Redis returns the number of members that were added with the
SADD command, not the size of the Set. Let's see this in action:
SADD languages "chinese" "japanese" "german" // 3 SADD languages "english" // 0
The first command returned
3 as we were adding three unique members to the Set. The second command returned
"english" was already a member of the Set.
We can remove members from a Set by using the
SREM key member [member ...]
We can remove one or more members at the same time:
SREM languages "english" "french" // 2 SREM languages "german" // 0
SREM returns the number of members that were removed.
To verify that a member is part of a Set, we can use the
SISMEMBER key member
If the member is part of the Set, this command returns
1; otherwise, it returns
SISMEMBER languages "spanish" // 1 SISMEMBER languages "german" // 0
Since we removed
"german" in the last section, we get
To show all the members that exist in a Set, we can use the
Let's see what language values we currently have in the
1) "chinese" 2) "japanese" 3) "spanish"
As Sets are not ordered, Redis is free to return the elements in any order at every call. They have no guarantees about element ordering.
Something really powerful that we can do with Sets very fast is to combine them using the
SUNION key [key ...]
Each argument to
SUNION represents a Set that we can merge into a larger Set. It is important to notice that any overlapping members will be listed once.
To see this in action, let's first create an
SADD ancient-languages "greek" SADD ancient-languages "latin" SMEMBERS ancient-languages
Now, let's create a union of
ancient-languages to see all of them at once:
SUNION languages ancient-languages
We get the following reply:
1) "greek" 2) "spanish" 3) "japanese" 4) "chinese" 5) "latin"
If we pass to
SUNION a key that doesn't exist, it considers that key to be an empty set (a set that has nothing in it).
In Redis, a Hash is a data structure that maps a string key with field-value pairs. Thus, Hashes are useful to represent objects. They
key is the name of the Hash and the
value represents a sequence of
field-name field-value entries. We could describe a
computer object as follows:
computer name "MacBook Pro" year 2015 disk 512 ram 16
The "properties" of the object are defined as sequences of "property name" and "property value" after the name of the object,
computer. Recall that Redis is all about sequential strings so we have to be careful when creating these string objects that we use the proper string sequencing to define our objects correctly.
To manipulate Hashes, we use commands that are similar to what we used with strings, after all, they are strings.
Writing and Reading Hash Data
field in the Hash to
key does not exist, a new key storing a hash is created. If
field already exists in the hash, it is overwritten.
HSET key field value
Let's create the
HSET computer name "MacBook Pro" // 1 HSET computer year 2015 // 1 HSET computer disk 512 // 1 HSET computer ram 16 // 1
HSET command, Redis replies with an integer as follows:
fieldis a new field in the hash and value was set.
fieldalready exists in the hash and the value was updated.
Let's update the value of the
year field to
HSET computer year 2018 // 0
HGET returns the value associated with
field in a Hash:
HGET key field
Let's verify that we are getting
2018 as the value of
year instead of
HGET computer year
Redis replies with
"2018". It checks out fine.
A fast way to get all the fields with their values from the hash is to use
Let's test it out:
1) "name" 2) "MacBook Pro" 3) "year" 4) "2018" 5) "disk" 6) "512" 7) "ram" 8) "16"
HGETALL replies with an empty list when the provided
key argument doesn't exist.
We can also set multiple fields at once using
HMSET key field value [field value ...]
Let's create a
tablet hash with it:
HMSET tablet name "iPad" year 2016 disk 64 ram 4
OK to let us know the
tablet hash was created successfully.
What if we want to get just two fields? We use
HMGET to specify from which fields in the hash we want to get a value:
HMGET key field [field ...]
Let's get the
ram fields of the
HMGET tablet disk ram
Effectively we get the values of
ram as replies:
1) "64" 2) "4"
That's pretty much the gist of using Hashes in Redis. You may explore the full list of Hash commands and try them out.
Introduced in Redis 1.2, a Sorted Set is, in essence, a Set: it contains unique, non-repeating string members. However, while members of a Set are not ordered (Redis is free to return the elements in any order at every call of a Set), each member of a Sorted Set is linked to a floating point value called the score which is used by Redis to determine the order of the Sorted Set members. Since, every element of a Sorted Set is mapped to a value, it also has an architecture similar to Hash.
In Redis, a Sorted Set could be seen as a hybrid of a Set and a Hash.
How is the order of members of a Sorted Set determined? As stated in the Redis documentation:
- If A and B are two members with a different score, then A > B if A.score is > B.score.
- If A and B have exactly the same score, then A > B if the A string is lexicographically greater than the B string. A and B strings can't be equal since Sorted Sets only have unique elements.
Some of the commands that we use to interact with Sorted Sets are similar to the commands we used with Sets: we replace the
S in the Set command and replace it with a
Z. For example,
ZADD. However, we have commands that are unique to both. Let's check them out.
ZADD adds all the specified members with specified scores to the Sorted Set:
ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
As with Sets, if
key does not exist, a new Sorted Set with the specified members as only members is created. If the
key exists but does not hold a Sorted Set, an error is returned.
Starting in Redis 3.0.2,
ZADD has optional arguments that gives us control of insertions:
XX: Only update members that already exist. Never add members.
NX: Don't update already existing members. Always add new members.
CH: Modify the return value from the number of new members added, to the total number of members changed (CH is an abbreviation of changed). Changed members are new members added and members already existing for which the score was updated. So members specified in the command line having the same score as they had in the past are not counted.
INCR: When this option is specified ZADD acts like
ZINCRBY. Only one score-members pair can be specified in this mode.
It's good to know that these optional arguments are there and what they do, but for this introduction, we are going to focus on adding members without using any of them, but feel free to explore them! In future posts, we are going to revisit them in more complex use cases!
Let's create a Sorted Set to store Help Desk Support tickets. Support tickets are meant to be unique but also need to be sorted, hence, this data structure is a great choice:
ZADD tickets 100 HELP204 // 1 ZADD tickets 90 HELP004 // 1 ZADD tickets 180 HELP330 // 1
ZADD returns a count the number of new elements added. In the commands above, we used the position of the ticket in a queue as the score value followed by the ticket number (all fictional).
We'd like now to see how our Sorted Set looks. With Sets, we used
SMEMBERS to list the unordered members. With Sorted Sets, we use a command that is more in tune with what we used with Lists, a command that shows us a range of elements.
ZRANGE returns the specified range of members in the Sorted Set:
ZRANGE key start stop [WITHSCORES]
It behaves very similarly to
LRANGE for Lists. We can use it to get a subset of the Sorted Set. To get the full Sorted Set, we can use the
0 -1 range again:
ZRANGE tickets 0 -1
Redis replies with:
1) "HELP004" 2) "HELP204" 3) "HELP330"
We can pass
WITHSCORES argument to also include the score of each member:
ZRANGE tickets 0 -1 WITHSCORES
1) "HELP004" 2) "90" 3) "HELP204" 4) "100" 5) "HELP330" 6) "180"
Notice how the
member and the
score are listed in sequence and not next to each other. As we can see, the members are stored in
tickets in ascending order based on their score.
Using Redis as a Session Store
The most relevant use of Redis in the authentication and authorization workflows of a web application is to serve as a session store.
As recognized by Amazon Web Services, the in-memory architecture of Redis provides developers with high availability and persistence that makes it a popular choice to store and manage session data for internet-scale applications. Its lightning-fast performance provides us with the super low latency, optimal scale, and resiliency that we need to manage session data such as user profiles, user settings, session state, and credential management.
Roshan Kumar, from Redis Labs, explains on his "Cache vs. Session Store" article that a session-oriented web application starts a session when the user logs in. The session is active until the user logs out or the session times out. During the session lifecycle, the web application stores all session-related data in the main memory (RAM) or in a session store that doesn't lose the data when the application goes down. This session store can be implemented using Redis that, despite being an in-memory store, is able to persist data by writing transaction logs sequentially in the disk.
Roshan further explains that session stores rely on reading and writing data to the in-memory database. The session store data isn’t temporary and it becomes the only source of truth when the session is live. For that reason, the session store needs to meet the "data durability requirements of a true database."
"According to @RedisLabs, a session store requires high availability and durability to support transactional data and uninterrupted user engagement. You can achieve that easily using #Redis."
Redis is a powerful, nimble, and flexible database that can speed up your architecture. It has a lot to offer including caching, data replication, pub/sub messaging systems, session storage, and much more. Redis has a multitude of clients that cover all of the popular programming languages. I hope that you try it out whenever you have a use case that fits its value propositions.
Auth0, a global leader in Identity-as-a-Service (IDaaS), provides thousands of customers in every market sector with the only identity solution they need for their web, mobile, IoT, and internal applications. Its extensible platform seamlessly authenticates and secures more than 2.5 billion logins per month, making it loved by developers and trusted by global enterprises. The company's U.S. headquarters in Bellevue, WA, and additional offices in Buenos Aires, London, Tokyo, and Sydney, support its global customers that are located in 70+ countries.