You will need the Swoosh gmail adapter. Swoosh.Adapters.Gmail — Swoosh v1.26.2
It works great, we use in dev and production

I already use it or at least I try to do so. I mentioned in my post that

I’m trying to send the emails (as explained here: Swoosh.Adapters.Gmail — Swoosh v1.26.2)

I forgot to say in my original post that I added a configuration entry for my MySecondApp.Mailer module that looks like this:

config :mysecondapp, MySecondApp.Mailer, 
    adapter: Swoosh.Adapters.Gmail

…but the Swoosh.Adapters.Gmail documentation says that I should also provide the access_token configuration like this

config :mysecondapp, MySecondApp.Mailer, 
    adapter: Swoosh.Adapters.Gmail
  access_token: {:system, "GMAIL_API_ACCESS_TOKEN"}

If I follow the documentation and do the configuration of the Mailer module like above and then send the email without specifying an access_token in the call to Mailer.deliver:

new()
|> to("test_email@example.com")
|> subject("Hello!")
|> text_body("some email body")
|> Mailer.deliver()

I’m getting the error:

2025-03-17 12:57:28.391 [error] GenServer MySecondApp.Services.EmailSender terminating
** (ArgumentError) expected [:access_token] to be set, got: [adapter: Swoosh.Adapters.Gmail, access_token: nil, otp_app: :mysecondapp]

My understanding is that somebody is supposed to set the system env GMAIL_API_ACCESS_TOKEN such that Swoosh.Adapters.Gmail can find it.

This is why I tried to get the access token by calling Goth.fetch but this call fails with

{:error, %RuntimeError{message: "unexpected status 401 from Google\n\n{\n  \"error\": \"unauthorized_client\",\n  \"error_description\": \"Client is unauthorized to retrieve access tokens using this method, or client not authorized for any of the scopes requested.\"\n}\n"}}

So, I’m totally confused. All I want is to obtain the access token the same way as the original application did and be able to use the same Goth configuration file, which works just fine in MyFirstApp when using Bamboo.

you are supposed to set the GMAIL_API_ACCESS_TOKEN on the system where the code is supposed to run.

But I don’t have an access token. The existing application (MyFirstApp) is using goth to obtain the OAuth access token automatically. Goth is configured with a configuration file like this:

{
  "type": "service_account",
  "project_id": ***,
  "private_key_id": ***,
  "private_key": ***,
  "client_email": ***,
  "client_id": ***,
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": ***,
  "universe_domain": "googleapis.com"
}

Maybe my question should not be “how to send email with Swoosh?” but instead “how to use Goth with Swoosh.Adapters.Gmail?”

Check the code for how Bamboo gmail does it:
https://github.com/parkerduckworth/bamboo_gmail/blob/master/lib/bamboo/adapters/gmail_adapter.ex#L1

As an example you are trying to specify different scopes.

You have:

scopes = [
      "https://www.googleapis.com/auth/gmail.send",
      "https://www.googleapis.com/auth/gmail.compose",
      "https://www.googleapis.com/auth/gmail.readonly"
    ]
    |> Enum.join(" ")

however, BambooGmail only wants the @gmail_auth_scope which is "https://www.googleapis.com/auth/gmail.send".

Check that code and I think you can make it work.

Hi @odeac , sorry for our previous reply, we just realized that the “service account” integration is different.

Here is a step by step instruction on how to Send email using Swoosh, Swoosh Gmail Adapter and Goth with the “service account”

Please note that a Google Workspace account is required for it to work. For a personal Gmail account, you must use the “refresh_token” integration

First lets create a new mix app, let’s call it Sample, as it is done in Swoosh documentation

mix new sample

Lets add our deps and run mix deps.get

      {:swoosh, "~> 1.18"},
      {:hackney, "~> 1.23"},
      {:mail, "~> 0.4.3"},
      {:goth, "~> 1.4"}

Create a config/config.exs

import Config

config :sample, Sample.Mailer,
  adapter: Swoosh.Adapters.Gmail

Create lib/sample/mailer.ex

defmodule Sample.Mailer do
  use Swoosh.Mailer, otp_app: :sample
end

and last for Swoosh a lib/sample/user_email.ex ( change your email and name to the the email indicated in the “sub” option in your Application (see below)

defmodule Sample.UserEmail do
  import Swoosh.Email

  def welcome(user) do
    new()
    |> to({user.name, user.email})
    |> from({"Your Name", "your_email@domain.com"})
    |> subject("Hello, Avengers!")
    |> html_body("<h1>Hello #{user.name}</h1>")
    |> text_body("Hello #{user.name}\n")
  end
end

For Goth to work we must create an lib/sample/application.ex ( change the “sub” email to one of the email connected to your Workspace account )

defmodule Sample.Application do
  use Application

  def start(_type, _args) do

    credentials =
      "GOOGLE_APPLICATION_CREDENTIALS_JSON"
      |> System.fetch_env!()
      |> Jason.decode!()

      source =
        {
          :service_account,
          credentials,
          [
            claims: %{
              "sub" => "sending_email@domain.com",
              "scope" => "https://www.googleapis.com/auth/gmail.compose"
            }
          ]
        }
    children = [
      {Goth, name: Sample.Goth, source: source}
    ]
    Supervisor.start_link(children, strategy: :one_for_one)
  end
end

We also need to start the app in mix.exs

  def application do
    [
      extra_applications: [:logger],
      mod: {Sample.Application, []}
    ]
  end

Please note that in this example we use env variable are we dont feel confortable putting the credentials into a json file, but feel free to change this.

Create an `.env’ at the root of the project ( make sure also that it is added to your .gitignore

export GOOGLE_APPLICATION_CREDENTIALS_JSON='{
  "type": "service_account",
  "project_id": "****",
  "private_key_id": "***",
  "private_key": "***",
  "client_email": "***.iam.gserviceaccount.com",
  "client_id": "***",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "***",
  "universe_domain": "googleapis.com"
}';

Run source .env and iex -S mix
At this point you shouldn’t have any log errors

To test Goth you can run Goth.fetch!(Sample.Goth)
It should return

%Goth.Token{
  token: "****",
  type: "Bearer",
  scope: "https://www.googleapis.com/auth/gmail.compose",
  sub: "sending_email@domain.com",
  expires: ***,
  account: nil
}

Now to send the email. Please note that we dont define the access token in the configuration but as an argument to the deliver function.

# In an IEx session
email = Sample.UserEmail.welcome(%{name: "Tony Stark", email: "tony.stark@example.com"})
Sample.Mailer.deliver(email, access_token: Goth.fetch!(Sample.Goth).token)

Regarding the Google account setup , you should be all set as you were previously using it but for others there is couple of things to setup
-Have a workspace account
-Enable Gmail API
-Create a Service Account
-Add compose scope to the ID of the service agent in Domain Wide Delegation ( only https://www.googleapis.com/auth/gmail.compose is required )
https://admin.google.com/ac/owl/domainwidedelegation?hl=en_US

Voila ! I hope this helps you and others. Feel free to ask questions if any

To be honest I don’t really know what I did wrong in my first attempt but I started from scratch and followed these steps and the email sending worked fine.

Thanks a lot for the detailed explanation!

You can still do a directory-wide diff between the first variant and the working variant. Could be curious to see what’s different.