Forem: Jeff Shillitto

How to create videos using HTML, custom fonts and the Shotstack API

Jeff Shillitto — Mon, 26 Oct 2020 23:45:54 +0000

Shotstack's HTML asset type allows you to create videos using HTML and CSS. Text and basic layouts can be styled and formatted using tags and attributes familiar to any web designer.

Here's a quick demo of what's possible:

It has the additional benefit of being able to use any font, allowing you to match your brand guidelines and giving you full control over typography and text styling.

In this tutorial we'll talk through the basics of the HTML asset type, how to use Google Fonts and how the process is slightly different from designing for a browser.

Before starting the tutorial make sure you have signed up for a free API key. Also, make sure you are familiar with making API requests with cURL or Postman. Our Hello World tutorial is the best place to start.

Creating text using HTML

Creating text in your video with HTML is a case of using the HTML asset with a snippet of HTML and CSS to apply styling.

The following JSON will create a basic title:

{
    "timeline": {
        "background": "#000000",
        "tracks": [
            {
                "clips": [
                    {
                        "asset": {
                            "type": "html",
                            "html": "<p>Style text in video using HTML and CSS</p>",
                            "css": "p { color: #ffffff; font-size: 42px; text-align: center; }",
                            "width": 450,
                            "height": 200
                        },
                        "start": 0,
                        "length": 5
                    }
                ]
            }
        ]
    },
    "output": {
        "format": "mp4",
        "resolution": "hd"
    }

The following video will be created:

In this video the text is rendered using the default system font with the color, size and alignment specified in our css parameter. Note also how the text is constrained and wraps in a specified text area of width: 450 and height: 200.

Using a custom font

It's unlikely you will want to use the default system font, so let's go ahead and add our own.

It is important to understand that Shotstack does not use a browser to render HTML so there is no support for @font-face configuration. Instead, the actual font TTF (TrueType Font) file must be downloaded and installed on our platform before it can be used to style text.

The API makes this easy, take a look at the JSON below:

{
    "timeline": {
        "background": "#000000",
        "fonts": [
            {
                "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/OpenSans-Regular.ttf"
            }
        ],
        "tracks": [
            {
                "clips": [
                    {
                        "asset": {
                            "type": "html",
                            "html": "<p>Style text in video using HTML and CSS</p>",
                            "css": "p { font-family: 'Open Sans'; color: #ffffff; font-size: 42px; text-align: center; }",
                            "width": 450,
                            "height": 200
                        },
                        "start": 0,
                        "length": 5
                    }
                ]
            }
        ]
    },
    "output": {
        "format": "mp4",
        "resolution": "hd"
    }
}

Notice that we added a font TTF file using the following JSON:

"fonts": [
    {
        "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/OpenSans-Regular.ttf"
    }
]

The src parameter points to a TTF file saved on our S3 account. We then use font-family: 'Open Sans' in our CSS. Notice that fonts is an array allowing multiple fonts to be used.

The creates the following video:

Styling text elements

As you would expect with HTML and CSS you can add additional styling to the text. Have a look at the JSON and video below which highlights individual words within the text.

{
    "timeline": {
        "background": "#000000",
        "fonts": [
            {
                "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/OpenSans-Regular.ttf"
            }
        ],
        "tracks": [
            {
                "clips": [
                    {
                        "asset": {
                            "type": "html",
                            "html": "<p>Style text in video using <b>HTML</b> and <u>CSS</u></p>",
                            "css": "p { font-family: 'Open Sans'; color: #ffffff; font-size: 42px; text-align: center; } b { color: #21bcb9; font-weight: normal; } u { color: #e83e8c; text-decoration: none; }",
                            "width": 450,
                            "height": 200
                        },
                        "start": 0,
                        "length": 5
                    }
                ]
            }
        ]
    },
    "output": {
        "format": "mp4",
        "resolution": "hd"
    }
}

You can see that we have applied styling to the words between the <b> tags and <u> tags.

Shotstack only supports a subset of HTML and CSS and is based on HTML4/CSS2. It is useful for basic text and simple table based layouts. Check our documentation for full list of supported tags and attributes.

Preparing fonts for use with Shotstack

As mentioned, Shotstack does not use fonts exactly like a browser, instead of @font-face we require the actual TTF font file.

One of the most popular requests we get is, how to use free Google Fonts with the Shotstack API. We'll show you how you can get the TTF file from Google Fonts to use in your video, and how to handle different font weights and styles.

The common mistake our users make is to use the embed code URL as the font src, typically something like:

"fonts": [
    {
        "src": "https://fonts.googleapis.com/css2?family=Montserrat:wght@400;700;900&display=swap"
    }
]

This will not work as the URL points to a text file with the @font-face rules.

Download the font family

To download a Google Font, open the page with the font you want to use, in our example we are using the Montserrat font. Instead of clicking 'Select this style', click on the 'Download family' link in the top, right corner as shown below:

This will download a zip file containing all the TTF font files. You can extract the files you want to use. If you double click on them you will be able to preview the font.

Each font has a number of variations for the weight and style, i.e. bold, black, italic, light, etc... You need to choose the actual weights and styles you want to use and upload them to a publicly accessible URL.

In this example, we have selected the following Montserrat font styles and uploaded them to our AWS S3 account:

Montserrat Regular: https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/Montserrat-Regular.ttf
Montserrat Bold: https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/Montserrat-Bold.ttf
Montserrat Black: https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/Montserrat-Black.ttf

Import these in to our video render using the following JSON:

"fonts": [
    {
        "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/Montserrat-Regular.ttf"
    },
    {
        "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/Montserrat-Bold.ttf"
    },
    {
        "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/fonts/Montserrat-Black.ttf"
    }
]

Using the correct font-family

The final step is to use the CSS font-family attribute to apply the font to our text. You need to select the correct font name. The easiest way to do this is to preview the font on your desktop.

For example, on Windows, the preview for Montserrat Regular displays the name like this:

The name is shown as Montserrat so the font-family rule will be set as:

font-family: 'Montserrat';

For Montserrat Bold, notice that the name is also Montserrat.

To display the bold variant, we either need to wrap the text in a <b> tag or use the following
CSS rules:

font-family: 'Montserrat'; font-weight: bold;

Finally for Montserrat Black, the name is Montserrat Black.

The font-family will therefor need to be

font-family: 'Montserrat Black';

Fonts, font styling and typography are an essential feature in all kinds of videos. Using the HTML asset and custom fonts should give you a wide range of options to brand your videos and add titles
and text in any kind of style you like to create the effect and impact your video needs.

Hello World - edit your first video using the Shotstack API

Jeff Shillitto — Wed, 22 Apr 2020 02:24:29 +0000

Shotstack is a cloud based video editing platform. A REST API is used to describe a video edit sequence and a server based rendering service is used to render hundreds of videos concurrently.

This is the obligatory 'Hello World' guide that every programming language, framework and platform requires.

In this tutorial we will walk you through creating your first video using titles, a video clip, a soundtrack plus a few tips to give your video that final polish.

The basics

Before diving in and writing any code it is a good idea to acquaint yourself with some basic video editing principles and how these relate to Shotstacks JSON video editing format.

An edit in Shotstack is essentially a JSON file describing how assets such as titles, video clips and images are arranged to create a video.

Timeline

The timeline represents the entire duration of your video in seconds. For example, a 30 second video edit would have a 30 second timeline. Clips are placed along the timeline via a track.

Tracks

A track runs for the entire duration of the timeline and is used to layer clips on top of each other, for example, layer text on top of an image or video clip. You can place multiple tracks on top of each other.

Clips

Clips are placeholders for assets (titles, images, videos) and are positioned on the timeline (via a track) at specific time intervals. For example, you could add a clip that starts playing at the 5th second until the 10th second. You can also apply transitions, filters, and motion effects to the clip.

Assets

When creating a clip, you specify the type of asset to be displayed such as a text title, image or a video clip. Each asset has options specific to its type, for example, a title will have a type style and video might have a trim point to cut the start and end of the clip.

Output

The output specifies the final render properties, the platform supports mp4 video files and gifs in a range of resolutions such as HD, SD and mobile.

If this does not all make sense yet, it will all become clearer once we create a few examples.

Getting setup

Signup for API keys

In order to use the API you will need an API key. The API is free to use by developers so that you can learn, experiment, and develop applications. Sign up or login via the Shotstack website to receive a developer key.

Curl vs Postman

This tutorial presumes a basic knowledge of interacting with API's and using the command line. The examples use Curl but if you are familiar with Postman you can use the JSON, credentials and endpoints to achieve the same results.

To check Curl is installed, type the command in your terminal or command prompt:

curl --version

If successful you should see a response like:

curl 7.64.0 (x86_64-pc-linux-gnu) libcurl/7.64.0 OpenSSL/1.1.1b zlib/1.2.11 libidn2/2.0.5 libpsl/0.20.2 (+libidn2/2.0.5) libssh/0.8.6/openssl/zlib nghttp2/1.36.0 librtmp/2.3
Release-Date: 2019-02-06
Protocols: dict file ftp ftps gopher http https imap imaps ldap ldaps pop3 pop3s rtmp rtsp scp sftp smb smbs smtp smtps telnet tftp 
Features: AsynchDNS IDN IPv6 Largefile GSS-API Kerberos SPNEGO NTLM NTLM_WB SSL libz TLS-SRP HTTP2 UnixSockets HTTPS-proxy PSL

Curl is installed on most modern operating systems including Windows 10, Linux and OS X. If it is not available, install via your OS package manager or download from the Curl website.

Your first edit

Let's create a very simple Hello World title video.

Create a text file called hello.json with the following:

{
  "timeline": {
    "background": "#000000",
    "tracks": [
      {
        "clips": [
          {
            "asset": {
              "type": "title",
              "text": "Hello World",
              "style": "future"
            },
            "start": 0,
            "length": 5
          }
        ]
      }
    ]
  },
  "output": {
    "format": "mp4",
    "resolution": "sd"
  }
}

In the JSON above we specify a timeline with a black background, a track with a single clip which plays for 5 seconds and uses a title asset with the text 'Hello World'. The output is specified as an mp4 video with SD resolution.

Now post the edit to the API for rendering by running the command below:

curl -X POST \
  -H "Content-Type: application/json" \
  -H "x-api-key: ptmpOiyKgGYMnnONwvXH7FHzDGOazrIjaEDUS7Cf" \
  -d @hello.json \
  https://api.shotstack.io/stage/render

Make sure you replace the x-api-key parameter value above with your own staging key. Make sure you use the staging key and not the production key.

You should see a response similar to:

{
  "success": true,
  "message": "Created",
  "response": {
    "message": "Render Successfully Queued",
    "id": "d2b46ed6-998a-4d6b-9d91-b8cf0193a655"
  }
}

Copy the response id returned by the API as we will need it in the next step.

To check the status of the render run the following command, replacing the id at the end of the URL:

curl -X GET \
  -H "Content-Type: application/json" \
  -H "x-api-key: ptmpOiyKgGYMnnONwvXH7FHzDGOazrIjaEDUS7Cf" \
  https://api.shotstack.io/stage/render/d2b46ed6-998a-4d6b-9d91-b8cf0193a655

Be sure to replace d2b46ed6-998a-4d6b-9d91-b8cf0193a655 with the id returned by the API.

The video should only take a few seconds to render. Once it is ready the response will show a status of done and include a URL to the final video file:

{
  "success": true,
  "message": "OK",
  "response": {
    "id": "d2b46ed6-998a-4d6b-9d91-b8cf0193a655",
    "owner": "hckwccw3q3",
    "plan": "sandbox",
    "status": "done",
    "url": "https://s3-ap-southeast-2.amazonaws.com/shotstack-api-stage-output/hckwccw3q3/d2b46ed6-998a-4d6b-9d91-b8cf0193a655.mp4",
    "data": {
      "output": {...},
      "timeline": {...}
    },
    "created": "2019-04-16T12:02:42.148Z",
    "updated": "2019-04-16T12:02:51.867Z"
  }
}

If the status is not done (it might show queued, rendering, saving, fetching, or failed), then wait a few seconds and run the command again.

Once completed you can copy the URL and open it in your browser. You should see a simple 5 second video with the words 'Hello World' on a black background.

Congratulations, you have created your first video using the Shotstack API.

It is obviously a little bit boring so let's add a soundtrack and a background video.

Adding a video clip and soundtrack

Replace the contents of hello.json so that it looks like this:

{
  "timeline": {
    "soundtrack": {
      "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/music/freepd/motions.mp3"
    },
    "background": "#000000",
    "tracks": [
      {
        "clips": [
          {
            "asset": {
              "type": "title",
              "text": "Hello World",
              "style": "future"
            },
            "start": 0,
            "length": 15
          }
        ]
      },
      {
        "clips": [
          {
            "asset": {
              "type": "video",
              "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/footage/earth.mp4"
            },
            "start": 0,
            "length": 15
          }
        ]
      }
    ]
  },
  "output": {
    "format": "mp4",
    "resolution": "1080"
  }
}

In this example you can see that a new soundtrack motions.mp3 file has been added and as a second track with a video asset and a video file earth.mp4. The title and video clip have a length of 15 seconds.

It is important to note that the track with the video is below the track with text so that the text is rendered on top of the video file and not hidden underneath it.

Go ahead and use the previous Curl commands to post the video and check the status. You should end up with a video like below:

The video is now a lot more interesting, but it could still do with a bit of refinement to give it a more professional touch.

Adding the final touches to our edit

To add some final polish, we will reposition and resize the title and fade in and out the clips and soundtrack.

Replace the hello.json file with the following and post it to the API using the Curl command and check its status.

{
  "timeline": {
    "soundtrack": {
      "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/music/freepd/motions.mp3",
      "effect": "fadeOut"
    },
    "background": "#000000",
    "tracks": [
      {
        "clips": [
          {
            "asset": {
              "type": "title",
              "text": "Hello World",
              "style": "future",
              "position": "left",
              "size": "x-small"
            },
            "start": 4,
            "length": 11,
            "transition": {
              "in": "fade",
              "out": "fade"
            },
            "effect": "zoomIn"
          }
        ]
      },
      {
        "clips": [
          {
            "asset": {
              "type": "video",
              "src": "https://shotstack-assets.s3-ap-southeast-2.amazonaws.com/footage/earth.mp4",
              "trim": 5
            },
            "start": 0,
            "length": 15,
            "transition": {
              "in": "fade",
              "out": "fade"
            }
          }
        ]
      }
    ]
  },
  "output": {
    "format": "mp4",
    "resolution": "sd"
  }
}

In the edit above we have made several small changes including:

fadeOut effect on the soundtrack
fade in and fade out added to the title and video clip
position the title to the left and resize smaller
display the title after 4 seconds in time to the music
add a zoomIn motion effect to the title
trim the first 5 seconds off the start of the video clip

The result is below:

Next steps

This tutorial should give you a basic grounding in how the Shotstack API works and some of the core features used to programmatically generate videos.

Of course, using Curl on the command line is not practical when building applications but because the API uses JSON you can use the programming language of your choice.

Our API reference documentation will introduce you to all the available functionality and to help you get started we have examples
on GitHub using PHP and NodeJS.

Generate Daily Coronavirus Videos using NodeJS

Jeff Shillitto — Tue, 31 Mar 2020 11:59:42 +0000

I've been working on a Coronavirus video demo for Shotstack over the last week which we have released as an open source project on Github.

Using the daily feed of Coronavirus cases and deaths from Our World in Data you can generate a video for each country affected by the COVID-19 pandemic showing the increase in cases per day. It is quite a dramatic way to see the exponential growth of the virus.

Here is an example of a video generated for the United States from March 28th:

You can see a few more on our YouTube playlist.

How To Create Videos

The project is written in Node JS and is available on Github. The script has been set up as a cli tool to be run using npm (or Yarn) commands.

The first step is to checkout the repo from: (https://github.com/shotstack/coronavirus-data-video-demo).

The project is dependant on the Shotstack video editing API so a key is required. You can sign up for a free key via the web site at https://shotstack.io.

Follow the instructions in the readme file which will show you how to install dependencies, set up your .env file with your API key and the available commands.

The main commands are:

npm run dataset

This will download the latest CSV file from Our World In Data, who in turn source the data from the European Centre for Disease Prevention and Control (ECDC). The data is updated daily.

npm run list

This will display the list of countries with data available in the CSV file.

npm run generate -- --country 'United States'

Using the country of your choice, as displayed using the npm run list command you can queue a video for rendering by the API.

The script will poll the API every 5 seconds and after around 20 seconds a video URL will be returned which is the video file that can be downloaded or played in your browser.

How It Works

The Shotstack video editing API is a cloud based video editor that lets you automate the editing of videos using code. It uses JSON to specify how a video should be composed - how clips should be trimmed and sequenced along with the media type such as video, image, SVG, audio, text and even HTML.

The JSON edit specification is posted to the API which invokes a rendering engine that combines all the assets, saves the final video and returns the URL to an mp4 file. A Node SDK is also available which provides validated methods for the available features, authentication and API requests.

Using the fast-csv package the script first loops through the CSV file and groups the data by country.

The country data is then filtered based on the users selection and sent to a generateVideo method which loops through the data and every 2 frames (0.08 seconds) increments a counter with the number of cases, deaths and the date.

The data is passed to the Shotstack SDK to create frames and along with text, a background video and a soundtrack the edit is automatically composed.

Finally the complete edit JSON data is posted to the API to be rendered.

This process can be repeated for any country the user chooses and in theory all countries and data in CSV file could be automatically queued and rendered at once each day.

Open Source and Copyright

While the Coronavirus pandemic is a bleak situation I hope this is a useful demonstration of what our API is capable of. I am not sure how practical these videos are but I invite you to clone and experiment with the project (it is free to get started), get creative and hope you can build something that is more impactful.

The code is released under the MIT license and all assets used are CC0 which means they can be used anywhere without acknowledging the user or paying royalties or fees. You can of course use your own assets.

Building a GUI

Over the next few weeks we intend to build a front end web interface that would allow a user to create a video by choosing a country from a drop-down list. Please comment below if you think that would be useful or if you have a better idea.

How to Fake it as a Software Engineer

Jeff Shillitto — Tue, 25 Jun 2019 01:17:47 +0000

I have a confession to make; I have no idea what I am doing. Up until recently I was employed as a software engineer even though I’m not even qualified to use a computer let alone have a degree in computer science.

Over the last 5 years I faked my way up the ladder from working at a small creative agency to a large multinational corporation and finally landed a role at one of Australia’s leading tech companies, The Iconic, working in a large team of the country’s smartest software engineers, data scientists and product owners.

Like many developers, makers, hackers and hobbyists, I taught myself to code.

Building a website, integrating a CMS or e-commerce system, administering a database and managing a server, after a while become second nature.

At some point in your career, like me, you might find these simpler projects or working alone are no longer enough and you want to step up to being a fully fledged software engineer working with a larger team of like-minded engineers at a large corporation, tech company or fast growing start-up.

With Apple, Google and other large tech companies now saying they will accept applicants without a computer science degree it’s never been easier to fake it, so with that in mind, here are my top three tips on how to land that dream job.

Apply for jobs you aren't qualified for

This is my top tip and the one that had the most impact on my path to faking it. Apply for jobs even if there is little chance of success. I’d recommend aiming for jobs asking for 1–2 years of experience more than you already have.

Unless you are exceptionally talented there is a high probability you will be rejected. Don’t let this discourage you, try again elsewhere but be ready for more rejections.

Why? Because the feedback you get will be invaluable. Employers will tell you exactly what skills, technologies and techniques they are looking for. After a few applications and interviews you will start to notice a trend and you can get busy learning the most sought after skills you don’t have experience with.

This is the equivalent of market research, treat your future employer like a customer and work out what they want, then go away, adapt and deliver it.

Some questions that directed my approach to learning several years ago:

Explain your understanding of Polymorphism
What is your approach to unit testing your code?
Name three design patterns and when you would use them
How would you use caching to optimise performance?

Create your own side project

This is the best way to learn in my opinion and can also be the most rewarding. You can learn from books and online tutorials, but they tend to guide you down a specific path and completing a tutorial doesn’t offer the same thrill or sense of achievement that creating your own side project does.

By dedicating yourself to a side project, especially if you intend to release the source code or launch a software product to the public you will a) find yourself more committed to learning and b) you will be forced to develop your problem-solving skills — there is no guide telling you what to do, you’ll need to work things out yourself.

Side projects allow you to experiment, practice and demonstrate knowledge of the latest technologies, languages, frameworks, techniques and best practices that you might not have the opportunity to learn elsewhere, such as your day job.

A side project will also impress potential employers that you live and breathe software, that you love coding and you are on top of emerging trends.

Copy others work

They say if you can’t find the answer on Stack Overflow then it can’t be done.

If you want to learn fast and build things, then copy solutions from Stack Overflow, Google the answer or find something similar on GitHub.

The trick to faking it however is to critically evaluate the solutions you find, cross reference it against other suggestions and then look for how it can be improved and refined so that it looks like your own work.

But don’t stop there, if you already work with or know other software engineers copy what they are doing and learn from their hard work and mistakes. A good software engineer will be more than happy to coach and mentor you and pass on their knowledge.

You can do it

It should take no more than five years to be able to fake it as an accomplished software engineer and hopefully you can land that dream role with a much sought-after tech company. All it really takes is patience, hard work and dedication.

One last thing

Should you successfully fake it, your job then is to pass down your knowledge and wisdom you have acquired.

Answer questions on Stack Overflow, write a blog, or contribute to an open source project and encourage those on the same path as you to embrace their curiosity, develop their problem-solving skills and help them to become great software engineers.

Introducing Shotstack, the Cloud Video Editing API

Jeff Shillitto — Fri, 21 Jun 2019 09:26:36 +0000

Shotstack is a cloud-based API for creating and editing videos using a simple JSON format and a rendering engine that can render 1000's of videos concurrently.

The go to technology for server based programmatic video editing has traditionally been the open source utility FFmpeg. FFmpeg is a command line utility that performs video manipulation tasks such as transcoding, resizing, trimming and stitching clips together and applying a range of filters and effects. You might use it in your application by either executing it directly or via a wrapper library like PHP-FFmpeg or fluent-ffmpeg for NodeJS.

This is a great approach for simple, individual videos, but the commands can get complicated and features limited when you want to do more sophisticated editing.

There are also important considerations to think about when you start editing videos at any kind of scale; even a simple edit can consume 100% CPU for several seconds or even minutes depending on length and resolution of the input and output files.

Typically, you would solve this with a combination of queues, load balancers, multiple servers, instances or containers and auto scaling. All of this takes expertise, effort and time to setup and maintain.

I created the Shotstack platform to take away all this complexity and let you just focus on creating videos. The API lets you specify how your video edit is to be arranged using a simple to understand JSON format.

I have tried to reproduce a format similar to a non linear video editor like iMovie or Adobe Premiere with a timeline, tracks/layers, clips that work with images, titles and videos and a number of built in effects, transitions and filters that can be added with one line of code.

The other component of the platform is the server side rendering engine - just POST your edit to the render endpoint and it will take care of queuing your render job and scaling up a new instance to take care of the processing and rendering. Your image and video assets just need to be stored on an accessible URL and they will be downloaded into the edit. After a short period of time it'll spit out a final rendered mp4 video or a gif ready to download.

Why did I build this, you might be asking?

Shotstack started as a side project many years ago with the goal of using machine learning and visual recognition to automatically edit GoPro videos. The A.I. side of things proved more complicated than I anticipated but I had developed the back-end API and rendering engine and thought developers could use it to create their own automated, personalised, large scale video applications.

I've been speaking to a growing number of online video services, some creating millions of videos per month, that are building their own platforms. They are all building something similar, in isolation, spending months re-inventing the wheel and I believe this should be simpler - developers should be able to get setup and create their first video in minutes rather than months, freeing them up to focus on their application rather than infrastructure and maintenance.

I want to share the API with you to see what you might create. My goal is to create a WordPress like ecosystem of applications, modules and video templates that developers can plug together to create new kinds of video-based projects, applications and services.

I'm currently offering free access to the developer community to try out and experiment with the API and there is a GitHub account with some SDK’s, example code and demo projects. Register for keys here: https://dashboard.shotstack.io/registeror visit https://shotstack.io/ for more details.

I hope you will join me on this journey building a new way of creating video online.