If the situation really IS anywhere near that simple, I wouldn’t reach for a dependency…

defmodule MyApp do
  defmodule Customer do
    defstruct [id: nil, name: nil, addresses: []]
  end

  defmodule Address do
    defstruct [city: nil, state: nil]
  end

  def map_response(%{"_embedded" => %{"customers" => customers}}) do
    customers |> Enum.map(&make_customer/1)
  end
  def map_response(%{"_embedded" => %{"suppliers" => _suppliers}}), do: {:error, :not_implemented}
  # ..and so on, of course

  def make_customer(%{"id" => id, "name" => name, "addresses" => addresses}) do
    %Customer{id: id, name: name, addresses: Enum.map(addresses, &make_address/1)}
  end

  def make_address(%{"city" => city, "state" => state}) do
    %Address{city: city, state: state}
  end
end

response = 
%{"_embedded" => 
  %{"customers" => [
    %{"id" => 1, "name" => "Joe Shmo", "addresses" => [
        %{"city" => "San Francisco", "state" => "CA"},
        %{"city" => "Lake Tahoe", "state" => "NV"}
      ]
     }
    ]
   }
}

IO.inspect MyApp.map_response(response)
# [%MyApp.Customer{addresses: [%MyApp.Address{city: "San Francisco", state: "CA"},
#    %MyApp.Address{city: "Lake Tahoe", state: "NV"}], id: 1, name: "Joe Shmo"}]

However, if you need something generic for quite a few more use cases, and see it becoming hard to maintain, then yeah… do check out that library

customers -> %Customer requires 3 things.

1. Remove any keys that are not in the Customer struct.

   good_keys =  Map.keys(Map.from_struct(Customer)) |> Enum.map(&Atom.to_string/1)
   {step1, _bad_keys } = customers |> Map.get("customers") |> Map.split(good_keys)
   

2. Convert all the string keys to atoms.

    step1 |> Enum.map( fn {k, v} -> {String.to_existing_atom(k), v} end ) |> Enum.into(%{})
   

3. Add a :__struct__ key to the Map with Customer as the Module.

    new_customer = Map.put(step1, :__struct__, Customer)
   

Then you need to pull out the address list and apply the same kind of transformation for each
map in the list.