Share variable with all functions in a module

Hello, everyone!
I am having a really hard time wrapping my head around this one for some reason.
I want to get a token, store it in memory in a module, have it available for all the functions in the module, and update it when the token expires.
In other languages, I might do something like:

token = nil

def handle_token() do
  # Check if I already have a token
  if token do
    # If so, use it.
    # If not (or if it's expired), get a new one.
    token = Req.get(

This is obviously oversimplified, but I think you can understand what I mean. What is the idiomatically correct way to do this in Elixir?
I have looked into using ETS for this, but it seems like a lot.

I look forward to your feedback, and thank you!

Simply put, you don’t do that in an FP language (though there are escape hatches like ETS indeed).

You’ll get better responses if you specify your original problem – and not how you want to solve it.


Are you looking how you can handle state? If yes you can use Agents for storing something simple (a string)

As mentioned, you cant do what you are trying because modules are not classes, they don’t contain state.

For that you need a GenServer (which agent is just more simplified)

A GenServer would be perfect for that. You can even make it so that the GenServer automatically refreshes the token every interval.


defmodule TokenManager do
  use GenServer
  # Stick `TokenManager` in your Application's children
  def start_link(init_arg) do
    GenServer.start_link(__MODULE__, init_arg, name: __MODULE__)
  def token do, :token)
  def init(init_arg) do
    token = 1
    Process.send_after(self(), :refresh_token, :timer.seconds(2))
    {:ok, token}
  def handle_call(:token, _from, token) do
    {:reply, token, token}
  def handle_info(:refresh_token, old_token) do
    new_token = old_token + 1
    Process.send_after(self(), :refresh_token, :timer.seconds(2))
    {:noreply, new_token}

Edit: untested code FYI

For a similar case, when I need to use and update something, I use the following kinda programming pattern. But as @hlx mentioned, Genserver might serve best for your case without further knowing the context of your original problem.

defmodule SomeModule do
@state %{token: nil}

def some_function(params, state) do

def another_function(params, params2, state) do

def update_token(state) do
# update the token
%{token: updated_token}


So, I try to pass around states, between functions, so any update that happens in any function should be available to the next one. Not sure it serves your purpose, maybe you can add further context to it.

1 Like