![Mux Elixir Banner](github-elixir-sdk.png)

# Mux Elixir

![test workflow status](

<!-- MDOC !-->

Official Mux API wrapper for Elixir projects, supporting both Mux Data and Mux Video.

[Mux Video]( is an API-first platform, powered by data and designed by video experts to make beautiful video possible for every development team.

[Mux Data]( is a platform for monitoring your video streaming performance with just a few lines of code. Get in-depth quality of service analytics on web, mobile, and OTT devices.

Not familiar with Mux? Check out for more information.

## Installation

Add `mux` to your list of dependencies in `mix.exs`:

def deps do
    {:mux, "~> 3.2.0"}

## Quickstart

We'll put our access token in our application configuration.

# config/dev.exs
config :mux,
  access_token_id: "abcd1234",
  access_token_secret: "efghijkl"

Then use this config to initialize a new client in your application.

client = Mux.client()

You can also pass the access token ID and secret directly to `client/2` function if you'd prefer:

client = Mux.client("access_token_id", "access_token_secret")

Now we can use the client to do anything your heart desires (to do with the Mux API). From here we can
create new videos, manage playback IDs, etc.

{:ok, asset, raw_env} = Mux.Video.Assets.create(client, %{input: ""});

Every successful response will come back with a 3 item tuple starting with `:ok`. The second item
is whatever's in the `data` key, which will typically be the the item you were interacting with. In
the example above, it's a single `asset`. The third item is the raw [Tesla](
Env, which is basically the raw response object. This can be useful if you want to get to metadata we
include, such as the timeframe used or the total row count returned, or if you just want to get to
headers such as the request ID for support reasons.

## Usage in Phoenix

Creating a new client before making a request is simple, but you may not want to do it every
single time you need to use a function in a controller. We suggest using `action/2` to initialize
the client and pass that to each of the controller functions.

def action(conn, _) do
  mux_client = Mux.client() # or Mux.client("access_token_id", "access_token_secret")
  args = [conn, conn.params, mux_client]
  apply(__MODULE__, action_name(conn), args)

def create(conn, params, mux_client) do
  # ...
  {:ok, asset, _} = mux_client |> Mux.Video.Assets.create(%{input: ""})
  # ...

#### Verifying Webhook Signatures in Phoenix

Note that when calling `Mux.Webhooks.verify_header/3` in Phoenix you will need to pass in the raw request
body, not the parsed JSON. Phoenix has a nice solution for doing this [example](

Read more about verifying webhook signatures in [our guide](

defmodule MyAppWeb.BodyReader do
  def read_body(conn, opts) do
    {:ok, body, conn} = Plug.Conn.read_body(conn, opts)
    conn = update_in(conn.assigns[:raw_body], &[body | &1 || []])
    {:ok, body, conn}

# endpoint.ex
plug Plug.Parsers,
  parsers: [:urlencoded, :multipart, :json],
  pass: ["*/*"],
  body_reader: {MyAppWeb.BodyReader, :read_body, []},
  json_decoder: Phoenix.json_library()

# controller
signature_header = List.first(get_req_header(conn, "mux-signature"))
raw_body = List.first(conn.assigns.raw_body)
Mux.Webhooks.verify_header(raw_body, signature_header, secret)

You will most likely have to store the raw body before it gets parsed and then extract it later and
pass it into `Mux.Webhooks.verify_header/3`

<!-- MDOC !-->


## Publishing new versions

1. Update version in mix.exs
1. Update version in README
1. Commit and open a PR
1. After code is merged, tag master ex: `git tag v1.7.0` and `git push --tags`
1. run `mix hex.publish`