Developer-Friendly Messaging

So, you have a product or service that needs to send emails or text messages, and you have a reliable provider like Mailgun or Twilio.

Great — you’re good to go, right?

Well, no. First you’ll need some kind of template system. But where do you store the templates? And how do you test them with real data? Or make edits and preview the result? You’ll also need to hook up the templates to your provider, create plain-text versions of your HTML emails, make sure everything is secure, come up with a way to view sent messages in a browser ...

... on and on it goes. Then you’ll have to repeat all of it for every project!

Outkit solves all of these problems and more, with a specific focus on reuse in multiple projects or products.

Things that need to send emails or text messages
SaaS Product
Mobile App
Internal Tool
DevOps Script
Simple, unified API
Provider abstraction layer
Queueing and retrying
Template management
Visual template editor
Searchable message archive
Reuse across projects
Real-time message feed
... and lots more!
Mailgun
SendGrid
Amazon SES
Twilio
Email/SMS Providers - low-level delivery experts
  • JavaScript
  • PHP
  • Elixir
const Outkit = require('@outkit/outkit');

const client = new Outkit.Client({
  key: '',           // Fill in your API key
  secret: '',        // Fill in your API secret
  passphrase: '',    // Fill in your API passphrase (not your personal password)
});

// Construct a message record
const messageRecord = {
  type: 'email',                   // Message type - 'email' and 'sms' currently supported
  project: 'my-project',           // Project identifier
  template: 'my-welcome',          // Template identifier
  subject: 'Welcome, Jane!',       // Email subject (optional)
  to: 'some.name@example.com',     // Recipient address (and optional name)
  from: 'other.name@example.com',  // Sender address (and optional name)
  data: {
    name: 'John Doe',
    // ...
    // Add the values for any variables used in the template here
  },
};

// Then submit it
const message = await client.createMessage(messageRecord);


          
// Use autolading to be able to use our classes without explicitly requiring them
require __DIR__ . '/vendor/autoload.php';

// Instantiate a client by supplying API credentials
$client = new Outkit\Client(array(
    "key" => "",        // Fill in your API key
    "secret" => "",     // Fill in your API secret
    "passphrase" => ""  // Fill in your API passphrase (not your personal password)
));

// Construct a message record
$messageRecord = array(
    "type" => "email",                   // Message type - 'email' and 'sms' currently supported
    "project" => "my-project",           // Project identifier
    "subject" => "Welcome, Jane!",       // Email subject (optional, can also be set in the template or omitted for SMS messages)
    "template" => "my-template",         // Template identifier
    "to" => "some.name@example.com",     // Recipient address (and optional name)
    "from" => "other.name@example.com",  // Sender address (and optional name)
    "data" => array(
        "name" => "John Doe",
        // ...
        // Add the values for any variables used in the template here
    ),
);

// Then submit it
$message = $client->createMessage($messageRecord);


          
# Configure Outkit in your config files
config :outkit,
  key: "OUTKIT_API_KEY",
  secret: "OUTKIT_API_SECRET",
  passphrase: "OUTKIT_API_PASSPHRASE"

###

# Create a message
{:ok, message} = Outkit.Message.create(%{
  type: "email",                   # Message type - 'email' and 'sms' currently supported
  project: "my-project",           # Outkit project identifier (managed through our web UI)
  template: "my-template",         # Template identifier (managed through our web UI)
  subject: "Welcome, Jane!",       # Email subject (optional, can also be set in the template or omitted for SMS messages)
  to: "some.name@example.com",     # Recipient address (and optional name)
  from: "other.name@example.com",  # Sender address (and optional name)
  data: %{
      name: "John Doe",
      # ...
      # Add the values for any variables used in the template here
  },
})


          

By developers, for developers

Sending a message is just an API call away. You specify which template to use, supply the locals, and a recipient. We have dead-simple API clients for the most popular languages, with more on the way.

Our pricing model lets you set up messaging for as many projects as you want, without paying a cent before one of them reaches a meaningful volume.

Don’t repeat yourself

Setting up a robust messaging infrastructure is tedious and difficult. And creating essentially the same templates for many different projects is a huge waste of time that lowers developer happiness. Avoiding this repetition was the initial problem that Outkit set out to solve.

In our solution, inheritance is the key word: A project inherits from its team, and a template inherits from its project. This applies both to data (URLs, email addresses and so on), the actual template contents, and CSS/styling.

Getting a new template up and running can be as simple as changing a few lines of HTML - the rest is inherited.

T
P
B
T
=
Team Wrappers
P
=
Project Wrappers
B
=
Template Body
Email
SMS
?

Multiple message types, one API

Outkit lets you treat multiple messaging protocols - Email and SMS for now - as one. One simple, unified API is all you’ll have to deal with, and we’ll take care of the rest.

When it makes sense to support another message type, we’ll be ready - and so will you! Every part of Outkit has been designed to support multiple message types.

Trace your messages in style

Outkit lets you follow the flow of your messages in real-time. And whether there is a problem or not, you can inspect individual messages, and even see exactly what the provider response was - right down to the HTTP headers and status code.

Let us do the work for you

You don’t have to start from scratch when creating an Outkit template. Choose from an ever-growing list of pre-defined templates, where we have done all the hard work. All you have to do is tweak a few links, edit a text here and there, and maybe replace the logo image.

Pick a workflow that works for you

Different projects have different needs. Outkit supports three different workflows when it comes to generating the content of a message:

  1. We manage your templates, you just supply the locals
  2. Manage your templates outside Outkit (typically in your project’s version control system), and simply pass their contents to us along with the locals
  3. Send us pre-processed content for immediate delivery, bypassing rendering entirely
1
Your App
API Call
Locals
Rendering
Locals
Outkit Template
Outkit Styles
Final Content
2
Your App
API Call
Locals
Inline Template
Inline Styles
Rendering
Locals
Inline Template
Inline Styles
Final Content
3
Your App
API Call
Content
Final Content

Bring Your Own Provider

After we render your message with the data that you provide, we hand it off to your provider of choice. They handle all the low-level details of email delivery. You can configure any number of providers in Outkit, and switch between them with a couple of clicks – or per API call.

By providing this abstraction layer, Outkit lets you switch between different providers without a single change to your application code or your templates. It also means that your carefully maintained email/SMS reputation won’t be affected by using Outkit, and you can continue to rely on the features you love about your favorite provider.

So much to say, so little space

We have tried to address the main features of Outkit in some detail, but there’s much more we’d like to talk about.