All language subtitles for APIs for Beginners - How to use an API (Full Course ⧸ Tutorial).en

This course is an excellent introduction to APIs for beginners.

This is an updated version
of what is already one of

the most popular API courses on the Internet.

Craig Dennis is back as the instructor and in my opinion he is one of the best developer educators out there.

- Hello, I'm Craig and I'm a developer.

In this course, we are
going to be exploring

a term that you've
probably heard quite a bit.

That term is API or application
programming interface.

In addition to being able to
recite what it stands for,

when you complete this course,

you'll be able to
discuss what an API does.

You'll understand why they
exist and you'll be able

to list the many benefits
that they provide.

You'll even get some
hands-on experience using

a few popular web APIs,
which will give you

a taste of what all this
excitement is about.

We'll be starting from the very beginning,

so there really isn't too much I'm gonna

be expecting you to know
before starting this course.

I would like to request that

you have a touch of experience with coding

and a wee bit of knowledge about the web.

If you've written any program at all,

even the typical first program,

you know the one where you
write the words, "Hello, world."

If you've done that in
any programming language,

you'll pretty much be
ready for this course.

It will be helpful if you
have a basic understanding

of how the web works with
web servers and browsers,

but don't sweat it,
we'll touch on that too.

Now, if you haven't met these
requirements, please check

the notes attached to this
video for where to get started

with some beginning web
and programming concepts.

That reminds me, you should take some time

to get used to your learning environment.

The notes that I just discussed
are attached to this video

and I'll also drop more
information into that section

to keep you updated on
what might have changed

from my right now to your
right now and I'll do my best

to remind you to look in
there when there's something

I think you just have
to see, but you really

should get in the habit
of checking that area out.

There'll be tons of
juicy information there.

You might be getting a real
bad case of deja vu right now.

This is a refresh of a course from 2019,

which these days seems like
about 30 years ago or something.

If you saw that version, welcome back.

Technology is constantly
evolving and just updating

the notes wasn't cutting
it, so this is version two.

Thanks for all the feedback, by the way,

a lot of yours and your
fellow learner's suggestions

are implemented in this
new updated version.

All that to say, we got you.

These videos have captions,
so if you feel like

you might benefit from having
those on, please use them.

This space is all yours.

If you want me to speak slower,

please use the speed
controllers to slow me down,

and if I'm taking a
long time, speed me up.

I make a pretty good chipmunk.

And last but certainly
not least, take advantage

of the fact that you are
in a video-based course.

If you need me to repeat myself,

use the video controls to rewind me.

If you feel like you need
to take a break to let

something sink in, by all
means, please pause me.

I'll be right here waiting for you.

I know that I've gotten
into some pretty bad

viewing habits with all
this streaming media.

Now, while binging might be a great way

to consume an entire season
of your favorite show,

it's not the best way
to learn something new.

Education isn't meant to be
binged and because of this,

I'll probably remind you
quite a bit to take breaks

and encourage you to let what
you just learned marinate.

All right, let's get to it.

API, those three little letters

generate quite the buzz, don't they?

First, I'd like to take
some time upfront here

and clearly break down what is meant

by application programming interface.

By understanding its purpose
and a touch of its history,

I think you'll start to see
its importance and begin

to understand why this term
keeps popping up in your life.

After we get a good grasp on
the what and the why of APIs,

we'll go and learn how to
explore two existing ones.

We'll get familiar with
several handy tools

that you can use to interact
with web-based APIs.

We'll use those tools to
hit an external web API

to send actual text
messages and we'll get some

inteRESTing data back from a
streaming music service API.

Once we get some practice
using the APIs, we'll use them

in a web application that
you'll actually publish.

The application that we're
gonna be building is going

to receive user submitted
photos via a text message,

and then we'll use an API to
display a collection of all

these photos and you get
to come up with the prompt.

Send me the latest photo
on your phone, dog pics,

please, what's for
dinner, whatever you want.

I can't wait to see what you build

and what your family and
friends submit to it.

We are going to be strictly
using APIs in this course,

we won't be writing our own.

While you most likely are gonna end up

learning some best
practices in API design,

we won't be covering that specifically.

There are many great
courses available that show

the creation thought process,
and I've linked to some

of my faves in the notes
attached to this video.

In my opinion, the best
way to start learning about

any acronym is to focus
on each individual letter.

For API, I think we should start on

that last character, the I, interface.

Let's talk a bit about the interfaces

that you've seen already.

Interfaces are all around us.

For instance, this radio here,
it has a familiar interface.

The interface allows me to do
things like change the volume,

change the station, I
can turn it off and on.

I literally have no
idea how anything inside

this thing works, but still
the interface allows me

to control the way that it
works through the options

that are exposed and that's
pretty great, isn't it?

The magic that is happening is

completely abstracted away from me.

I'm still in control of what has

been determined that I, a user can handle.

Interfaces usually evolve over time,

like an alarm clock radio for example.

It has my familiar volume
and station controls

and it also adds some new features like

changing the time and setting the alarm.

I still have no idea how this
works implementation wise,

but the interface is something
that I can understand.

Usually, and as technology evolves

and new options come into existence,

they make their way into the
new versions of the interface.

Still abstracting away things for us,

but enabling us to be in
control of the new features.

Sometimes these physical
interfaces get so recognizable,

they even make it into GUIs.

Hey, did you hear that?

There it is again, GUI, G-U-I,
graphical user interface.

This is my streaming
music app on my phone.

There's my familiar Play button
in the user interface or UI,

and I know what the Play
button does when I press it,

but I have no idea how it does it

and I'm okay with that
level of abstraction.

What would I do in public
transit without music?

Like, talk to people? Hi, how's it going?

Now, the developer who wrote this

streaming music application, of course,

understands how the Play button works.

She coded the button so
that when it gets clicked,

the music starts playing.

Here's the thing though,
our developer is also

working with quite a
few interfaces that are

abstracting the way some
of the details for her.

For instance, she wrote code

that happens when the button is clicked.

She probably did that
using an event handler

on the button, like onClick.

What she didn't have to do,
however, was write the code

that makes the button interact
and change with the press.

She didn't have to write the code

that makes that familiar clicking noise.

It was already there for her.

Buttons are, in fact, an interface.

They provide the developer
the means of controlling

its interactions while abstracting way how

that actually works, implementation wise.

This button is part of the API

or application programming interface

and it's available from
the application framework

that was used to create the app.

Because most apps need buttons,

this interface has been
created and provided

to our developer or
application programmer to use.

By implementing the button
interface, our developer

was able to make her code run
when the button was clicked.

It's worth noting that
the code probably also

uses a media player API
that is provided with

the operating system of the
device like Android or iOS.

This media player API abstracts
away needing to understand

details of how to send
audio data to hardware.

The developer knows they just want to call

the play method on the media player API.

I suppose too, the song
isn't stored on the device,

it's being streamed over
the network, so a web-based

API call has been made over
the internet to get that data.

It's actually APIs all
the way down to the ones

and zeros providing
abstractions at many levels,

so let's take a look at what all

of these interfaces have in common.

They all define ways for us
to interact or communicate

with an object, whether
that object be physical

or software, and as a
user of the interface,

we don't need to understand
the implementation,

we don't need to know how it works.

We just need to know what
we've been allowed to change

or see, interfaces abstract
away the implementation.

Now, while the UI or user
interface is made for

the user of the
application, the API is made

for the application programmer

to use and extend in their applications.

With the I covered in our API,

let's take a deeper look at
the REST of the API acronym.

An API is a contract of sorts.

It defines how it is expected to be used

and it defines what you can
expect to receive by using it.

Think of it as a set of tools designed

for software developers
like yourself to use.

An API is created to help
make your life easier

by giving you access to
data and by providing you

with an abstraction of the
implementation, you know,

not needing to know how it's
doing, whatever it's doing.

They save you from needing to
create everything yourself,

like when designed well, they
make nearly impossible things

happen with just a few lines of code.

Now you're probably starting to see why

it's important to get
familiar with them, right?

I want to do a quick word
of warning here about some

naming issues that
you'll probably run into.

These days, the term API
is almost always used

as a way to explain web-based APIs.

In fact, it's probably
safe to assume that when

you hear API in the wild, it's most likely

that people are talking
about a web-based API.

We'll explore those here in a few.

However, if we focus on all types of APIs

instead of just the web-based subset,

we'll get a better look
into why web-based APIs are

so popular, so hang tight,
we're getting there.

APIs are everywhere in
your software journey just

about everywhere you look,
your programming language,

whichever one that might
be, provides many APIs.

Let's take a look at one that
is common in all of them.

They all provide some way
of working with strings,

you know, like a series of characters.

Wanna make your text all uppercase?

Just call the API method and voila.

You could probably create
the uppercase string all

by yourself by doing some
sort of low level bit math

on each character, but you don't need to

because your programming
language has abstracted away

that for you and provided
a handy string API.

It exists because this is

a common enough problem
that developers run into.

Because these programming
language specifications are

just interfaces, different
operating systems can supply

their own implementation so that the code

works properly in their environment.

I think an easy way of
picturing this is to think

about how different operating systems

like Windows or Mac OS
maintain their files.

They're totally different,
yet your programming language

provides a single API for
working with the file system.

You can write one script

and it works both in Mac and Windows.

It's the implementation that takes care

of all the details for
you, pretty cool, right?

Definitely something to be thankful for.

It makes our lives so much
easier not having to worry

about what operating system is
being used and the importance

of an API tool language
cannot be understated.

There have been some
fascinating legal cases where

it's been questioned if
the language API itself,

again, not the implementation
can be copyrighted,

check out the notes for more on that.

Along similar lines, there
are different web browsers,

you know, like Google Chrome,

Microsoft Edge, Safari, Firefox, Brave.

Now, you might not have
pondered this before,

but isn't it amazing
that you can write code

for the web and it will
work in any of 'em?

This works because
there's a set of web APIs

that web browsers all must implement

in order to make that
magic happen for you.

We are standing on the
shoulders of giants, folks,

and we really should thank
those giants more often.

There are authors and
maintainers of libraries

that package up code to
solve common problems so

that you don't need to do it yourself.

For instance, do you know
how to programmatically

make a photo black and white?

Me neither, but I can download and import

an image package into my
application and suddenly I can.

I just call a method and boom,

I wish real life skills worked this way.

I'd import dancing so I could

be more fun at weddings, cha cha cha.

Frameworks provide an API
that allow you to extend

what has been provided
to make it your own.

Like for example, most web
frameworks provide you with

the ability to add a new
route to your web application.

It allows you to write out dynamic data

to a template that you
specified, and you do all

of this with just a
handful of lines of code.

You don't need to understand
how it's doing things,

but you do need to know how
to write an implementation

to what the framework is expecting.

In this case, you're using
the API, the contract,

to write a valid implementation
that meets the requirements.

Now, all these APIs that
we just talked about,

they're local to our code base,
they exist within our code.

We use them to avoid recreating the wheel.

That is to say they assist
us in accomplishing tasks

that we need to perform
by abstracting away

a ton of the work for us, the stuff that

we developers shouldn't be worrying about.

We should be focusing on the
business problem at hand,

and that means a big part
of your job is figuring out

how to leverage these
APIs to your advantage.

Now, I think this is an excellent time

for you to take a break.

I just gave you a lot to think about

and I'd like you to take
some time and breathe.

Why don't you jot down some
APIs that you've used today?

Even if you weren't coding,

I know that you've seen some in action.

If you're having a hard
time thinking of some,

I'll give you a hint.

You're watching a video right
now inside of a web browser.

When we return, we'll explore
the concept of remote APIs,

ones that aren't executing
locally in our code base

and why that is such a powerful concept.

(upbeat music)

It took me a while to
find this remote control.

It was in the couch.
It's always on the couch.

Anyways, this remote has
an interface on it, right?

There's a Power button and when
I press the Channel button,

it changes the channel, when
I press the Volume button,

it sends the request to my
radio and the volume changes

as if I turned the volume
up using the interface on

the device itself, and we
know why that's important.

I want to remotely control my device.

I don't want to get up from my chair.

There are of course, more
or less lazy reasons as

to why we'd want to
remotely control objects.

This cute little robot, for
instance, has a remote API.

You can send commands
to it and it responds

and it even sends back sensor information.

These traffic signs can
change based on an API call.

This drone here is remotely controlled

by an app on my phone, see?

(drone whirring and crashing)

And it's not just physical objects

that benefit from remote APIs.

Oftentimes we don't have
space on our local machines

for all the data that's
available, like for example,

have you ever used one of those apps

that helps you figure
out what song is playing?

You send up a snippet of a
song that you heard playing

at a grocery store using your microphone,

and it sends back exactly what song it is.

It's usually Phil Collins.

It turns out that both grocery stores

and yours truly love Phil Collins.

You don't have room for all the songs in

the world on your phone
and with this remote API,

you don't need to have all of them.

It does all the searching and processing

and it's surprisingly quick.

How can it possibly do that?

I don't know, but I love
the interface. It's so fast.

Ooh, that's another benefit

of remote APIs, computational power.

Because an API removes the
limitations of your local device,

you can gain access to seemingly
infinite amounts of power.

A good example of this is the
AR app of Google Translate.

You can use the camera on your phone

and in near real time it's
able to translate directly

to your screen, like instantaneously.

It's using a ton of processing power

to make that magic happen
and that processing

is happening elsewhere, "en la Nube."

It took quite a bit of experimentation

and some evolution of
ideas, but over time,

we finally turned this remote
API dream into a reality.

Now, I'm gonna drop some history
into the teacher's notes,

but I just want you to
know that the struggle

to achieve this concept of
remote APIs was very real.

Now, most of the problem was that

there wasn't a standard
that everyone loved.

Things were pretty clunky for a while as

these ideas were sussed
out, but then it happened.

A new architectural style
appeared that was clear

and allowed us developers to interact

with specific resources over the web

and it quite literally changed everything.

This style rapidly emerged as a winner

and just about everyone began offering

and consuming external
APIs over the internet.

Now, what I'm talking about here is REST,

or representational state transfer.

It was the approach that
we needed and honestly,

it's the abstraction that
we developers deserved.

Like we talked about already,
the popularity of REST spread

so rapidly that it nearly
completely overtook the term API.

It's like how we use the
word Xerox to mean photocopy,

even though Xerox is just
a brand of photocopier.

Xerox does other stuff too, I think.

That's how pervasive REST is.

REST is for sure not the end
all, be all of remote APIs.

There are definitely some limitations

which we'll discuss here in a bit.

Technology's ever evolving and of course

there's movements that are still advancing

the concept of the best remote APIs.

Some terms you might even
have heard, like GraphQL,

more on this in the teacher's notes.

Now, for the rest of this
course, we are going to do

a deep dive into APIs that are
written using the REST style.

When APIs embrace the style
and constraints of REST,

they are said to be RESTful, cute, right?

If you feel like you need a little rest,

go ahead and pause me
before we do a deeper dive

into what it means to be RESTful.

Sorry, that was a bad and obvious joke,

but as a developer you
kind of have to make it.

You don't really have an option.

Because REST sits on
top of web technologies

like a really nice hat, we should probably

do a whirlwind refresher
of how the web works.

(upbeat music)

It might have been a while since

you thought about how the web works.

There are a smattering
of terms that I'd like

to reload into your working memory before

we talk more about how REST uses them.

So let's use the web, I've
got my computer here and on it

is an internet browser,
the browser is a web client

and I'm going to use it
to connect to a server.

I'm going to do this by putting

a location in the address bar,

a universal resource
locator or URL to be exact.

You might also hear this referred to by

its superset term URI,
universal Resource Identifier.

Now our URL here has a scheme portion

and this one happens to be HTTP.

HTTP stands for hypertext
transfer protocol.

Let's break that down a bit.

Let's grab that last part, protocol.

A protocol is also often
likened to a contract.

It's a little lower level than an API,

but it's similar in concept.

You can think of it as defining

the expectations of how to communicate.

Like an example that I think really sticks

with me is if you've ever been to a rally

and someone does one of those chants where

they're like, "When I
say 'Fu,' you say "Bar."

Fu, bar, one of those. Here, let's do one.

When I say HTT, you say P, HTT, HTT.

Oh, I just realized I might
have made you yell "P" out loud.

Hope you aren't in a coffee shop. Awkward.

Anyways, we, you and I just
set up a real quick protocol.

I told you how to respond
to my specific request

and you would've been breaking
or agreed upon protocol

if you yelled anything
else but P, so the browser

creates an HTTP request for
you, along with the URI,

it also specifies a particular HTTP verb.

In this case, it is using
the get verb, which is used

to clarify that this request
will only receive data.

That is, it won't be making any changes.

The server receives the request

that was transferred from the client.

There's that second T.

The server then does the
work that it needs to do.

Finally, it generates
the resulting webpage

and sends back a response to the client,

my browser, in this case.

The most important part of
the response is the body.

For a webpage, that contains

the HTML, hypertext markup language,

which gives us the remaining
parts, the HT of our acronym.

Hypertext is text that
can link to other texts.

In HTML, we perform that
linking with anchor tags,

so with that response, the
browser renders the page.

When one of those links are clicked,

they kick off a brand new HTTP get request

and the process repeats
itself over and over.

In between those clicks
though, the protocol's done,

we've made the request,
we got the response.

HTTP, as it was originally designed,

is a stateless protocol.

Once that request receives
a response, it's all done.

If you wanna keep some sort of
state, your client will have

to manage that itself and send
it up with each new request.

Check out the notes for more on this.

There are more http verbs,
also known as request methods

besides get, most common
scenario you see is when you

encounter a form that is used
to take information from you.

Typically you'll see the
verb post used to explain

that you are submitting or
posting data to the server.

Okay, so our protocol
that's used to transfer

this hypertext is admittedly a little

more complex than our rally chant was.

There's quite a bit of
important information in there

that is included in the
request and the response.

You've probably seen query
string parameters in URLs

and you know the stuff
after the question mark?

This is one way to pass
information about the request.

Another common way this
information is passed around

is through specific key and
value pairs called headers.

Both requests and responses have headers

and they're used to
help further communicate

what is wanted as well as
what has been sent back.

Some of the popular request
headers allow you to specify

information about the
content that you expect back,

like the language or the type of content.

You can also state that you want the page

if it has changed since a certain time.

This technique allows for caching,

which is a powerful concept.

Why get the whole page if you already

have it in your local cache?

You can embed authentication information

in each request using a header.

In this way, you're essentially keeping

your client logged in across requests.

This response also contains headers.

A super important one is the status code.

This lets you know what
happened on the server side

and can convey things
like missing documents.

I'm sure you've seen the
old 404 or maybe the page

has moved, but hopefully
everything is a 200 OK.

It can also explain the content type,

how large the data returned
is, and many more things.

Okay, got it?

Are you feeling good about
that little whirlwind tour?

Remember, feel free to
make me repeat myself

if that was too much, I totally get it.

That was a lot of information.

It's important to have
a basic understanding

of these things because
REST sits on top of them.

It uses the concepts that
were introduced with the web

to expose resources that can
be accessed and manipulated.

Let's take a look at
how the RESTful approach

takes advantage of the web and its tooling

for your benefit, profit.

REST stands for
representational state transfer.

APIs that meet the REST architectural

style constraints are
considered to be RESTful.

Now, a typical way to
teach about RESTful APIs is

to cover the constraints
that define it all upfront.

Now, I don't know about
you, but personally I find

approaching learning that
way pretty overwhelming,

especially from the beginning.

I mean, we haven't even
looked at an API yet.

On top of that, most of the REST APIs

that you'll use will meet
all of these constraints.

So here's the thing.

I promise that we'll go
over all the constraints,

but let's do it on our own time,

like don't learn 'em
all right this instant.

We could even make it a fun journey,

like a RESTful constraint scavenger hunt,

complete with prizes,
avoid where prohibited.

Here are the guiding
architectural constraints required

for an API to be considered RESTful.

We'll check them off when we discuss them

and then we'll loop back once
more at the end to review.

Gotta collect them all, sound fun? Good.

Let's get started talking
about how REST API sits on top

of web technology, like a
little hat, much like the web,

the client makes a request to a server.

The client in this case is typically going

to be your program and
you'll probably be using

some sort of library to create
the request to the server.

The protocol used, you guessed it,

it's HTTP and it's stateless.

The server won't remember anything

about the particular client.

If you wanna maintain state
like your login details,

you must send it with
each and every request.

You'll do this using
headers and just like that,

we talked about two of
our REST constraints,

client server architecture and stateless.

You got two knocked off
already. You're on a roll.

Now, we should probably talk about

what that request was requesting, right?

Well, it most certainly was

requesting information about a resource.

Now a resource is a little
abstract and that's intentional.

It's the R in the URL or URI.

We use the term resource
to reference an object.

Also happens to be pretty abstract, right?

And this is because we can use resources

to describe just about
anything that we build.

For instance, let's imagine
an e-book store website.

On the homepage, there's a list
or collection of new books.

Each of these books is a resource.

We click in to take a closer
look at that book resource

and we see a link to the author,
which is also a resource.

We click into the author
resource and we see

a collection of all the
other books they've written.

Maybe we even see a group of fans, again,

another collection, and each
of those fans are a resource.

Clicking into a fan
resource, we see a collection

of their favorite authors and books.

Everything is a resource.
Let's change gears.

How about an image sharing
application on your phone?

So we have user resources
and those users post photos,

which are resources, and
those photos can be loved.

So there's a lover resource,

maybe there's an album
that could be created.

There's an album resource
that contains photos

and albums have a collection
of contributor resources.

Turns out almost everything
we ever want to build

can be expressed in terms of
resources and collections.

Most of what we want our
applications to be able to do

to the resources can be
expressed through the

unfortunate sounding acronym
CRUD, and that stands

for creating, reading,
updating and deleting.

Now, as a user of the e-book site,

all we did was a bunch of
reading, no pun intended.

I actually did intend that one.

We were reading, right?

Just getting information
to display it like

we retrieved the author
page, we made a read request.

The web browser used a get request

to the specific author page.

The RESTful API follows the same logic,

your program sends a get request to a URI.

Then the server responds with data

and of course all the HTTP headers

you've come to know and love.

The body is typically represented

these days as JSON or
JavaScript Object Notation.

JSON provides a great way to
structure and nest your data.

Every programming language
that I can think of provides

some means of turning a JSON
string into a native object.

The content type is
typically something that you

can specify in your request
if JSON isn't your thing.

If you recall, there are
other HTTP verbs available.

These verbs are used in REST APIs

to clearly state the
intention of your request.

Wanna add an author?

Host to the /authors
endpoint and send the data

that you want to update in
the body of your request

and these fields will be
defined for you somewhere.

Wanna remove an author?

Send a delete to that
specific author resource.

Updates typically support the patch verb,

and you'll see we're able
to represent our CRUD needs,

the create, request, update
and delete using HTTP methods.

Pretty cool, right?

What this means is that
you can interact with

any application out there
that's exposed their REST API.

You could grab data,
remotely automate tasks,

and even smoosh together
different services.

This is called a mashup,
and here's the thing,

there are a ton of APIs
available, just about anything

that you can imagine, and
if they're truly RESTful,

they'll all feel pretty much the same.

You can build anything, there
are services that allow you

to do incredible things with
just a few simple API calls.

So now the question becomes
what are you gonna build?

So why don't you take a quick
break and when you come back,

let's explore a RESTful API together.

We'll take a peek at how to use
the music streaming service,

Spotify and their excellent RESTful API.

(upbeat music)

You have some newfound understanding

of how web-based APIs work.

I walked you quickly through some

imaginary REST APIs and now I'm thinking

it's time that we get
a little more specific.

Why don't we go exploring together?

Some of these REST APIs
allow you to give it a try

from the comfort of your
very own web browser.

One of my personal favorites that allows

for exploration is the streaming
music service, Spotify.

So here I am at spotify.com.

Now, a quick word of warning,
it is going to look different.

I guarantee you this site
is gonna look different

because they're always
making things better for us,

for us Spotify users, us lovers of music,

and as well us developers.

So I want you to try this.

When you go to a site,
any site that you want to,

you'll see here that this is really nice,

Spotify's letting us kind of test out what

it feels like in the web, on the webpage.

But if I scroll down to the bottom,

that's typically where
they hide nerdy stuff.

Now, I knew this was
here, but if I didn't,

I would look around for
something like this,

this Developers, and I'm
going to click into here.

Oh, I cannot tell you how good it feels as

a developer to end up in
a place where it feels

like you're being taken care of, right?

This is so nice.

The Spotify for Developers,
it looks like it

was thoughtful and I can tell
you that it is very nice.

It's a very nice tool.

You can scroll down, you
can see all sorts of stuff.

They give you some examples

of what you might want to do, right?

What could you build with this?

So you could find out
like different things,

like you could use the
API to see the beats

and the sections and the bars.

I think that there's a way to figure out

if a song is danceable or not.

So maybe I could import
dancing. We'll see.

And if I scroll back up to the top here,

you'll see that there's
these different headings.

We've got this Discover,
I think this is great

if you're going to explore
things, we have this Docs,

you'll see that there's all
types of different, actually,

APIs and SDKs, software
development kits, which are APIs,

which allow you to do different things.

You'll see that there's ones for iOS,

there's ones for Android.

What we're gonna be focusing
on is the one for the web APIs.

So if I click into that,

we'll get a nice overview of what this is.

I'm gonna blow this up just a little bit.

So you'll see based on some simple REST,

representational state
transfer principles,

that's what we're doing, that's
what we're going through.

We're going through our scavenger hunt.

We're going through that.

There's a Spotify web
API that returns JSON,

JavaScript Object Notation about

music, artist, albums, and tracks, right?

So that's awesome. That's great.

So we can see all sorts
of different stuff.

It opens up at this api.spotify.com is

the specific URL and then it has a set

of endpoints with each unique path, right?

Each of those URLs that
we were looking at before,

there is a way to get specific data.

So you could do this
thing where you authorize.

So, I could be a user,

you could see what I recently listened to.

I could have a playlist,
I could add to it.

But in order to do that, you need

to have authorization
to be able to do that.

You don't wanna be able to just add

to anybody's playlist, right?

So there is some
authorization that's available

and we are not gonna do anything
that requires that here.

So if you keep on looking down here,

you'll see that there's, it's based on

those REST principles and you'll see that

it does get to retrieve resources, right?

And there's the post to
create resources, and again,

resources here are songs
and artists and tracks.

Maybe the resource you're
creating here is one

of those playlists that we talked about.

You can change using a put

and a delete will delete the resource.

So awesome, right? So it's
using REST like we saw.

You'll see that Spotify
uses this URI style.

So it's a Spotify track and then it

has this unique ID, this Spotify ID.

This will make more
sense as we dig into it

a little bit more and then
you'll see that there's always

this Spotify URL that allows
you to see what it was.

And it will show you this as well.

As we said, the responses come back

and they are a JSON object
and we're gonna be looking

here at a tool in the future called Curl,

which you can use from your command line.

That's what this dollar
sign here is talking about.

I'll show you all this,
but basically it's saying

that there's a lot of
artists that come back.

You don't want all the
artists in it, it will

come back paginated and of
course, you can use caching.

We'll take a look at that here,

you can see if the thing
has changed or not.

So we'll take a look at that
and basically the response

that comes back, if everything's good,

it's gonna say a 200 or these,
these 200 level accounts.

And then there's bad requests.

So if you ask wrong or
maybe it wasn't found,

that's the 404 or unauthorized,
if we try to do one

of those playlists, we get an unauthorized

and there's also if you're a developer,

you never wanna see
this one, it's the 500.

It means that you made an
error on the server side.

We won't be doing any of those 'cause

we're just gonna be hitting
somebody else's code.

Cool, all right, so Spotify
offers the ability to,

you can look at this and
you can build your own

curl request, but one of
the really nice things

that I love about their
API, and you'll find

this happens often, if
we scroll back up here

to the top, sorry if I'm
making you sick there,

we're gonna jump in here to
what's known as the console.

Over on the left are the
things that we can do

with their API and one
of the things I wanna

do first is I want to
search and you can see

it's making a get to the search endpoint.

So I'm gonna go into there
and what's really nice

is it's set it up so that we can kind

of build the query that we're looking for.

So now we need to decide
what we're gonna do.

I think probably the
first person that I would

ever search for, the first
artist I would search for.

And you can see that here it's showing

the different values of what that is.

I would probably search for Beyonce.

I mean, right, wouldn't you?

And I could choose, is
that a track or an artist?

So the type there is important,
and if I type artist,

you'll see that what's
happening is you'll see

the curl here is changing,
it's changing the,

it says the cue is the Beyonce.

So that's one of the parameters that

we're passing into the
API and artist is here.

And you can see there's different things

that we could do here.

What's really important is that it

needs to have this OAuth token.

Now what's nice is we
can build one of those

even if we don't have a Spotify account.

So I'm gonna do that.

I'm gonna click this Get Token,

I am not currently logged
in and I actually don't

have a Spotify account yet in this user.

I do have a Spotify
account. I love Spotify.

And this is asking,
basically what you would do

is you would create a
specific OAuth token.

If you were ever to use this API outside

of where we're doing this right now,

you would create one of these
tokens so that you could

log in later and you say
what it is that you want.

So here's the playlist, right?

We don't, we're not gonna do
any of the playlist stuff,

we're just gonna do a search.

Maybe we'll look up some
of Beyonce's tunes, but,

so I'm gonna go and I'm gonna
click this Request Token.

So now it's asking me to either log in

with my Spotify account, which I can,

or I can create a new one,
and let's walk through that

just in case you don't have
a Spotify account already.

Let's create a new one.

And this will be at my
developer account here.

So I'm gonna put in my email.

So my email, I don't know
if you know about this,

but if you use Gmail you
can do a little plus sign

and it will still send to
the left side of your Gmail.

So I'm gonna do at Spotify
sign up and that way

any emails I get from
here, it will have that.

And it's kind of a way to let
you have multiple accounts.

And I think, so again, my Gmail
is craigsdennis@gmail.com,

but I'm gonna do SpotifySignup@gmail.com

and it will go to my Gmail.

It'll just kind of ignore
this, Gmail does that for you.

It's pretty nice, right?

So I'm gonna put in the
same password as my luggage,

which is 1, 2, 3, 4, 5, 6, just kidding.

And what should we call you?

Oh, you know what?

I love it when you call me Big Poppa,

that will appear on my
profile, I am ready for it.

And let's see, it is my
birthday on November 19th, 19.

Let's see, what do I, I think,

wouldn't it be nice if I was born in 1999?

What is your gender? Oh, this is nice.

How nice. This is like super inclusive.

I love that this is so inclusive.

It's like somebody at
Spotify went and talked

to their people and listened
to what people wanted

and they included people
who identify as non-binary

or other, or prefer not to say.

So like wherever you sit in
that I love and hats off to you

Spotify for being inclusive,
'cause inclusivity matters.

Share my registration data.

Sure, why not? I am not a robot.

I don't think I am. Oh, oh no.

The images with bicycles.
That one's got a bike.

That one's got a bike.
That one has a bike.

Oh, what is that garbage there?

Is that, this is a bike
lane. This is a bike.

Okay, here we go, please.
Okay, I am not a robot.

Thank you. All right, so
I'm gonna click Sign Up.

Oh, I am male. I am male.

So here we go. That's how I identify.

All right, I'm gonna save that log in

and I am going to log in with it.

So here we go. All right.

So it's asking me if I have
access to this developer console

and it'll see my logged in
as Big Poppa, here we go.

And now you'll notice here that

there is this token here, right?

This is this OAuth token that got created

for me by Spotify and it's putting it into

this console for me so it can share it.

Now you never wanna let your token out.

If you get a hold of, somebody gets a hold

of your token, they can
do stuff on your behalf.

And I realize that this is
on a screen being recorded

and I'm going to get rid of
this token here in a bit.

So you will not be able to have it.

So I've got this token,
it's filled out here.

I'm gonna click Try It

and we're gonna do a search for Beyonce.

Let's see what happens.

So you will see that we
got some information back.

So we got a list of artists,

'cause that's the type
that I searched for.

And this is the search that we did.

We'll see some external URLs

and we think that this is probably her.

I'm gonna see, I'm gonna
grab this really quick,

but you can kind of see how
things are laid out here, right?

So this is my Spotify URL for that.

Let's see if this is
her, this looks like her.

Yeah, yeah, definitely. So, great.

"Crazy in Love," "Cuff It."
I haven't heard that one yet.

Awesome. So this is Beyonce, great.

So we got her, we found
her, we used this search.

It has, shows how many followers she has.

Wow. 32 million.

Good job. And it tells the the genre.

So we can do all sorts of
really cool stuff with this.

And it's here, you'll see
that I'm getting a URL,

I'm getting a link that will open up

her specific artist page, right?

So, here is her ID.

So if I take her ID,
I'm gonna grab this ID

and I'm gonna come over
here to Artists and I can

come in here and I can show
all of the artist's albums.

So you'll see it'll be artists/ID/albums.

Let's see all of the albums that she did.

But let's look at that in JSON format.

So the artist that I want,
I'm just gonna pipe that ID in

there from before, right, now
it still has my bearer token.

The console has done that
for me and I can go ahead

and do Try It and we should see that now,

it's gonna return back albums, right?

So we've made a get request to
the albums and I can see all

of the albums that she's
had here and we can see

where they're available in
different markets as well.

Looks like she's available in lots

of markets all over the world.

Who runs the world? All
right, so here we go.

We are going to look, let's
see, these are albums.

That's the artist there.
That's the type of the artist.

Let's get one of the albums here,

let's make sure that we got it.

So you see that it's got
different things like I could

get access to maybe the
image of what this album is.

So let's do that, I'm
gonna post that here,

open that up and let's see, there she is

on her horse, her magical horse there.

So that's pretty cool,
right? This is awesome.

I can get access to all
sorts of information

about an artist I can get by their ID.

I can go and find all
sorts of different things

that I wanted to do, right?

So, if I knew an album
too, once I have the ID,

I could get the ID, I
could get the tracks,

all sorts of amazing things.

And then there's these playlists, right?

So you can add a playlist, if I wanted to,

I could post to create a playlist.

Now of course I need to
authenticate to do that

and that's a little bit
of what we're doing here,

but I could add, put together a playlist

for everybody to do using this API.

And again, when we are
looking at the artists,

when when we're looking
at this get artist,

it's showing this curl command

and we're gonna take a
look at that here in a bit.

But I just want to take
a little bit of time.

I want you to go and take a look, go back

to this Discover section and kind

of get inspired by
what's available, right?

So you can look at, there's
these different things

where you can, I was right, you can check

and see if there's danceability of a song.

You can go and find a
track and is it danceable

and you know that Beyonce's
is, the songs are gonna

come back very high in the
danceability thing there.

But lots of powerful
things and there's lots

of cool examples that
you can do that people

have already gone and built.

And you can take a look
at how they built it

and how they use the API recommendations.

This is awesome, really
this is like super wide open

to you and you can do all of this

because of the APIs that they provide.

Pretty cool, right?

You can get access to all
of Spotify's music library

and you can build tools
that extend their platform.

I highly recommend that
you go and take a look

at what other people have
built using these APIs.

It's super impressive.

Did you notice how fast
those results came back?

How could it do that search so quick?

Oh wait a second, does it even need to?

Those results don't change all the time.

It's not like Beyonce is
dropping a new song every minute,

though I wish she would.

Those results are definitely
cacheable, ding, ding ding.

Cacheability is also
available on the client

and we'll get to that here in a bit.

But this is a great example
of a layered system.

I'm almost positive that Spotify has

set up things so that
it returns the same JSON

from its own server
side caching mechanism.

It's not rendered that
on every single request.

As a user of the API, I don't know how

it's doing that and frankly, I don't care.

I want it to be available

and fast when I hit that specific URL.

Beyonce definitely appreciates

how fast the results will return.

She might even take that
API dev to Red Lobster.

Let's go ahead and take a
quick break, during this break,

I'd love for you to move
around and think about

what you might be able to
build with that Spotify API.

For instance, while I was using this API,

I had this idea pop up.

When I'm at a music festival,
I often have a hard time

deciding which band I should
go see, there's so many.

Now I would love to have an app suggest

to me which of the bands that are

currently playing I
would most likely enjoy.

You know, based on my listening habits,

I'm pretty sure that you
could build that just

with the Spotify API and using a list

of events of the bands
that are performing.

And if you do end up building that,

share it with me 'cause I need it.

What other interests do you have

that provide an API that you can use?

Check the notes for more ideas.

Now, after you come back from your break,

let's dive a little deeper and make use

of an API using our own
tools, see you soon.

No really, take a quick break.

Seriously, it'll do you good. No binging.

(upbeat music)

While I realized that exploring

an API on a website is informative,

it might not feel like you're
actually using that API.

I think the next logical step in exploring

is actually making that request yourself

from your computer, not from a website.

Now as I pointed out in the Spotify docs,

there were examples that were
using a command called Curl.

Curl is an open source tool
that is used to send data back

and forth and it runs
locally on your computer

and it's awesome for
poking around at APIs.

What do you say we explore it a bit?

Okay, so we are back
here on our Spotify page

and we see that there is a
command here that says Curl.

Curl is a command that we
can run from our terminal.

Now if both of those terms are new to you,

command and terminal, this
is a great time to head over

to the notes and learn
about what the terminal is.

So my operating system is a Mac

and it has an application
on it called Terminal.

So I'm gonna open that
up, Terminal, and in fact,

I'm gonna make this a little bit bigger.

Let's go ahead, let's let
it take up the whole screen,

we're gonna be in here for a little bit.

So I'm gonna type Clear
and clear my window.

All right, so this terminal

allows me to perform
actions on my computer.

Like I can make it do text to speech.

I can do Say and I can say, "Hi mom."

- Hi mom.
- And it says, "Hi mom."

And the Windows operating
system has a terminal as well.

And while it's a little bit different,

they're actually pretty quite similar.

But check the notes for more on this.

So what happens is I write the command

and then I pass in
values for the parameter.

In this case, it's "Hi mom."

Now, note that I used
quotes there because I wanna

pass one value, even
though there is a space,

if there was a space, that's
kinda how you separate things.

But with the quotes it's saying

this is one value that I'm passing in.

We developers spend a lot
of time in our terminals,

so if this is new to you,
I want you to remember

that it was new to everyone at one time.

So please take your
time and don't let this

get you too frustrated, you've got this.

So I already have Curl installed.

I'm gonna just go ahead
and make sure that I do

by typing the word
"curl," and if I see this,

I could see that I could type curl

and then the command "--help."

Now if I didn't have this installed,

if this came back with like, I don't know

what you're talking
about when you type curl,

the word curl, that's okay.

So we're gonna head over to the notes

and you'll get sorted there.

But the starting point, where
I want you to go is curl.se.

So you'll come to this page,

you'll see this as a command line tool

in library for transferring
data since 1998.

And that logo sure feels
like that, doesn't it?

It does all sorts of things.

What we're really concerned
about is this HTTP, right?

We're going to use this from

the command line to get access to a URL.

So if you don't have curl
on your command line,

go ahead and pause me and
check out the notes for

the best way to get this
installed on your computer.

There's a lot of different ways to do it.

If you come here under Download,

you'll see that there's
different operating systems.

So you've got your Linux
and you've got your Mac OS.

And if you come down here,
you've got your Windows.

So there's different ways
of getting things installed.

So go ahead, take your
time, get that installed.

And when you come back,
I want you to try this.

I want you to do this thing with me.

So I'm gonna go back to my terminal

and I'm gonna make sure that it works.

The way that I always
like to test is I like

to go to icanhazdadjoke.com.

How do you get a baby
alien to sleep? You rocket.

Oh, so good. Anyway,
that's how you do that.

That'll let you go and
it's gonna hit that website

and it's gonna give you back
a joke when you're ready.

So now that we've got
our curl up and running,

we've got our successful dad joke,

let's go ahead and run
that command from Spotify.

So I'm gonna come back
over to my Spotify thing

where I was running the search.

I'm gonna make sure
that it's still working

actually before I get
started, 'cause these tokens

can expire and depending
how long your break was,

it might have expired,
but mine is still working.

So I got this back here and I should

be able to get this from my command line.

And what I'm gonna do is
I'm going to copy this,

I'm gonna highlight this.

This is a development practice known

by US developers known as copy pasta.

So I'm going to copy this and I am going

to go back to my terminal and I'm going

to paste and this long
list of things here,

what this is doing is just saying, hey,

I wanna make a get request to
the api.spotify.com/v1/search.

Remember, that's where we were at.

We were searching and we're
passing the query string

of Beyonce and the type of artist

and we're telling it, "Hey, I would like

to get back JSON and I
am sending you JSON,"

even though we're not
actually sending JSON.

The default has that there
and this is an important one.

This is sending you a header, right?

The "-H" is a header and authorization.

And this is that long
token that we had there.

Now if all is working, when I press Enter,

I should get here locally
on my machine that same list

of data that we did and
I did, check that out.

So what I'm gonna do
is I'm gonna come back

up here and I am going to grab, wow,

there's a lot of information here, right?

When this comes back,
I'm gonna grab her ID.

And so I remember that
when we were looking at it,

it was down in here, this
ID, is this the right one?

Is that the first one?

So we got items, no, this is
her ID here, this is her ID.

It starts with a six, VW.

So I'm gonna copy that
and I'm gonna use that.

I'm gonna go back and
remember I'm gonna go

and I'm gonna look, I wanna
see what albums she has.

So I'm gonna come into here
and I'm gonna remember,

I'm gonna paste this URL
here, and I'm gonna run this,

make sure that that's still working.

I'd like you to go ahead and pause me.

I think I'd like to see can you

get her albums locally on your machine?

Can you go ahead and make sure that

you can do the same Get Artist,

see all of Beyonce's albums
on your local machine?

So here's what we'll do, you give it a try

and if you, once you
get it printing locally

on your machine, you
can let me know and then

unpause me and I'll show
you how I did it, okay?

Are you ready? You got this.

Pause me.
(upbeat music)

Cool. So how'd you do?

So here's probably one way that you could

have done it is just copied that, right?

Copy this whole thing and pasted it.

But what I wanna show you
is that we have access to,

we know what these URLs are, right?

So we know that there's
this v1 artist and in fact,

we can see that there
is a get of /v1/artist.

And then you can actually pass their ID

in the URL there, right?

That's what this ID is here.
So, let's just go back.

I'm gonna show you a little trick too.

So, I've got her ID copied
still, so I could have just,

just ran that query and copied
the curl and pasted it here.

And if you did that, you did it right.

I just wanna show you a little bit more

of what else, how else we could explore.

So I'm gonna press the up arrow

and you'll see my cursor's moving here.

I'm gonna press the Option key on Mac.

I think you're gonna press
the Alt key on Windows.

You can jump around like
this and I'm going to get rid

of what's here, and I'm
gonna say v1 artists, right?

So that's the collection of artists.

And I have that specific ID, right?

So there's the ID and I'm
gonna press Enter here

and you'll see that I got back
Beyonce, which is awesome.

That's what I did and then
remember, the artists have,

I'm gonna go to the front of the line,

it's Control+A on Mac,
and I'm gonna switch this

so artists have, this is
specific artists, so Beyonce,

and we wanna see Beyonce's slash albums,

which is what the console
would've generated for you.

But I just wanted to show
you that you can kind

of navigate and move through
and you'll see that there's

a bunch of different information
that comes through here.

It's kind of hard to see, right?

So, kind of hard to parse.

And this is something
optionally that you can do.

So I press the up arrow
and I'm going to press,

pipe that into a tool
called JQ and you'll see

that it comes back very
nice and pretty, right?

So this is something that is very nice

to have and I piped that.

That's this, the symbol
above the Enter key is

this pipe symbol and it allows
you to take whatever happened

in this first part of the
command and take its results

and put it in this part of the
command, which is super cool.

And again, this is in the notes.

You don't need to, you don't
need to worry about this,

but I know that I can query things.

So I can say that of the items,

I'm only interested in the name,

the .name from each one of the items.

And this is a little query language

that's attached to this JQ program.

You don't need to do this,
this is just something,

if you're doing it from the command line,

it's something that we do that
we could kind of hack around

with a little bit and
you'll see I can get all

the lists of her albums and
that's pretty cool, right?

That's powerful, and if
you are gonna just start

poking around and moving
around with the URLs,

one thing I wanted to make
sure that you're cautious

of is if we come back
and we take a look at

the console page here, they
do a nice trick for you.

If we're back here in search,
like one of the things

that I wanna make sure I know
that Beyonce has this song

that's like something like,
who runs the world, right?

Who runs the world? Girls.

But I don't remember
where, what album it's on.

So I'm gonna search for a type track.

Now, note that my query has spaces here.

Now what's happened here is
it's done this URL encoding.

So like if you were trying
to mess around and work

with the search, you'd wanna
make sure that whatever

you did, you passed that
with those plus signs there.

So I'm gonna run that curl command

and we'll see who runs the world, girls.

And I am going to, I see
there's this open link here.

So I'm gonna go ahead,
I'm gonna open that.

Let's take a look and make
sure this is the right track.

I'm pretty sure it is, it
is not the right track.

What is this? Femme phan?

Maybe it's some other, some others.

So let's take a look.
Well, that's interesting.

So, oh, I just went to the bottom

instead of going to the top.

So I should have went to the
very top of these results

or I should have pulled,
probably pulled the name out.

Rock-a-bye, baby. There's a
Rock-a-bye baby version of this.

Whoop, okay, so when the color stops,

hope you're not getting
sick of all this scrolling.

So Beyonce is the artist that we want.

So this is the one, we
want to hear this song.

Let's see if I got the
right one this time.

This is just something, you know,

there's a lot of data coming back here.

It's kind of hard to do,
to use on the command line.

Sometimes I'm a little
cutsy like you just saw.

Here we go. Let's see what happens.

Let's make sure this is it.

There it is. There's Beyonce.

Not the song I was looking for.

Oh yeah, it is, "Who
Runs the World? Girls."

And now I can listen to that.

So it's like, who runs the world? Girls.

It's kinda like who
runs the terminal? Curl.

Boy, that was a big setup
just to make that joke.

I hope that you enjoyed
it. You can has dad joke.

Curl is an awesome way to
explore APIs and you'll find

that often, just like we saw with Spotify,

APIs will use Curl in their
docs to show you how they work.

Spotify is just one API and there are

so many companies and services out there.

In fact, some APIs are the product.

Like that's what the company's
selling to us developers.

So now that we've been
building up those muscles,

why don't we take a swing at another API?

Let's use a different API,
this time let's use Twilio.

Twilio is a company that loves APIs.

In fact, that's what
the company started as

more than a decade ago,
just a set of APIs.

It started as abstracting
away communication channels.

And by that I mean any way you'd ever

possibly want to
communicate with your users.

Wanna send a text message?
There's an API call for that.

Wanna make a phone call? There's an API.

Send an email, a WhatsApp message,

literally whichever way
you want to communicate,

there's an API for all of them.

Developers embed these
APIs into their apps

and I'm pretty sure that you've probably

used it without even knowing you were.

Now, nowadays there's a
whole suite of products

that Twilio offers that they
saw their customers needing.

But under the covers it's still

these APIs that are powering everything.

I need to be a little
upfront here with you.

I love Twilio, I mean, I love it so much,

I even applied for a job
with them and I got it.

But even if they didn't hire me,

I know that I'd still show off
how powerful their APIs are.

I mean, with a single command,
you can send a text message.

I remember when I first
did that, I was like, whoa.

Like that level of abstraction is amazing.

I mean if you've never
thought about it before,

what even is a text message?

I mean, I know I have an
app on my phone and I can

use it to communicate with
literally anyone else.

But how does that work?

Like there's all those different

cell carriers and standards
and phone numbers.

I mean, I have no idea.

And with Twilio, I don't need to know.

That's the beauty of this API.

It just works here, let me show you.

All right, so here we are
at twilio.com and again,

word of warning, this is going to look

completely different from my
right now to your right now.

So please make sure that you
check the notes for anything

that might have changed
and is specifically about

this flow that we're
about ready to do 'cause

we're going to sign up
for a trial account.

So I'm gonna click the Sign Up button here

and this is going to look
completely different.

I know because our team is
constantly making this better.

But the one thing that I
wanna make sure that you know

right now is that you see that there is no

credit card required and it
is a free Twilio account.

So I'm gonna put my information in here

and I'm gonna use the same
trick that I used before

where I do plus and I'm gonna
say, "APIcourseV2@gmail.com."

So, the plus sign there
again, the little Gmail trick,

we're gonna go ahead, I'm
gonna put in my password again.

1, 2, 3, 4, 5, 6, my luggage.

How many times can I do that joke?

And then I gonna do this accept,

must be 16 or more characters.

Okay, there's some password
requirements over there.

I think that's 16. All right, here we go.

Starting my free trial.

I'm ready. Let's do this.

I'm definitely gonna
save that long password

'cause I need that for later.

All right, so I have now
should have been sent an email.

So let me make sure that I
got that email and I did,

I am going to click the link
to verify it and here we go.

I'm gonna verify my phone number to verify

I'm a human 'cause all humans have phones.

So we're gonna do (432)-527-4274.

Please don't call too late.

I'm gonna try that.
I'm gonna click Verify.

All right, so I got my verification code.

Hey that came very quickly.

Well that's wonderful, my
verification code is 017869.

Hopefully your code's different than that.

Wouldn't they be funny if
they were all the same?

All right, so here we go.

So which product are we here
to use? We're gonna use SMS.

We're gonna use the SMS messaging product

and what do we plan to build?

Let's see the, of course,

these questions are gonna be different.

What are we gonna do?

We're gonna build, what?
Build something else.

We're gonna build something else,

how do we wanna build with
Twilio, with code, right?

So we are gonna end up
writing code if we want to

with minimal code on top of
code samples or no code at all.

So, definitely don't need
code to build over here

but I'm gonna say with code
'cause we're developers here.

So what is your preferred coding language?

We're gonna do JavaScript
even if it's not,

we're gonna be doing JavaScript
for the rest of this course

and I do want to host my code
on Twilio, which is nice.

There's a nice serverless option.

These options, like I said
are totally going to change.

Just try to answer them
as truthfully as you can.

So, and my building country is
United States, which is true.

And I'm gonna get started. I'm
gonna go ahead and walk this.

I guess let's go ahead and so
we'll I can explore products.

There's way more products that

are available than you can see here.

This is what got built based on the menu

of what they thought,
but if I ever want to,

I can come to this Explore
Products and get more,

we probably won't need to do that

'cause we filled out what we're gonna do.

And this is where you can
get access to your logs.

I'll show that off here in a bit.

If there's any problems you'll
be able to find them there.

Manage your account keys

and build trust with your customers.

Yeah, we can build all sorts
of different things in here.

We probably won't need to do too much here

'cause most of the keys
that we have are available

to us right from this page
that we're on actually.

So we'll keep going and I can
see the billing and again,

you're in a trial account and I think

you get something like $15 to try with.

So we'll be sending a text
messages using that trial.

Dollar dollar bills,
y'all. So, here we go.

And then you can switch between products.

So you can have multiple accounts, right?

So if you wanted to come and
like explore a little bit,

do your own personal thing,

maybe do something for
work later, up to you.

There's a 1550 is what we got. All right.

So, and then I'll click
Next and then I can,

anytime I want to, I can look
at this tour again to help

navigate around, which is
really nice, beautiful console.

So we could definitely go
ahead and the first thing

that we wanna do is we want
to get a Twilio phone number.

So I'm gonna do that.

I'm gonna click this,
Get Twilio Phone Number.

And I am so glad that this happened to me.

It says that this account
has been restricted

from provisioning new phone numbers,

which means that thinks
that I might be spam.

And you know why it is, it's because I put

that Gmail account with a
little plus thing there.

So if this happens to
you, I don't want you

to feel offended or anything like that.

I want you to check the notes

for the latest ways to get around this.

And also I'm going to go
right now and I'm going

to email compliancereview@twilio.com

and I should get that up and running.

If this happens to you,
go ahead, press Pause,

check the notes here for what to do.

And I'm going to actually do that.

I'm gonna press Pause here.

I'm gonna get my account
able to get a phone number

and I will see you back
here in one second.

All right, so I got all sorted out.

So I sent my email to the compliance folks

and I was able to say that I was doing

a personal account and
I'm learning how to use

these APIs and they were
able to let me get in here.

So what I'm gonna do
now is when I click this

Get a Twilio Phone Number,
we're not going to see

that message 'cause I'm
coming in and I've got

a new phone number and it automatically

gave me this one, this one here, this 561.

It went away really
quick, but it's down here.

This is my Twilio phone
number, this (561) 816-5433.

Now this number is mine, which is awesome.

I can use this message,
I can send messages,

I can receive messages,

I can do all sorts of things with this.

I can make calls, I can receive calls.

This Twilio phone number
is mine to play with.

I think we should do just that.

We should send a text message.

Now before we get started,

I wanna make sure that
you know this stuff,

you are on a trial account.

So there are some limitations.

You can only send messages

and make calls to verified phone numbers.

So when we set things up, we've verified,

like I'm able to send a text to myself

because I verified my phone number.

I mean, and it will say,

"Sent from my Twilio account," beforehand.

And there's more things
about your trial account too

if you wanted it to get into that.

So, check the notes because
this very well could

have changed, but check
the notes for more on this.

So let's do it. Let's send a
short message service, an SMS.

So I'm gonna click here
on this Docs and Support

and I'm gonna click
this, it's gonna open up,

I'm gonna go these developer
docs, these developer docs

are some of the best that
are available out there.

I want you to see these.

So we're gonna come in here under SMS

'cause that's what we're doing, right?

Short message service, and
under here, under these,

these sides on the docs
here, you can collapse these.

So I'm gonna come in
here under API reference.

I'm gonna go to this message resource.

Now this is an API, right?

So we're in the API reference.

So the API that we want
to do is we wanna be able

to send from, and we wanna
say from the phone number

that we just got and we wanna send

a message to my phone number, right?

So we're gonna do that and you'll see that

over here on the right, there are things

that you can do that
show you what you can do.

So with this message we can
do all these different things.

We'll start with creative message,

we'll create a message first.

So we're gonna go into
this, create a message

and there's these
different languages here.

So we have no JS and you can see the style

that it looks like, we'll take a look at

something like this here real shortly.

This is a helper library
that wraps around the API.

So you don't need to
do the sorts of things

that we're about ready to have to do.

You can do things a
little bit more cleanly.

But what we're gonna
look at is Curl, right?

So here's our friend, Curl.

We're gonna jump over here to
Curl and the docs have this

really nice thing where I'm
able to actually copy this.

So I'm gonna click to copy this

and I'm gonna pop over to my terminal.

Now again, I'm running on a Mac.

So there's a couple of things
here that this is assuming

that it's going to be okay
because I am running on a Mac.

It's going to assume that these slashes,

see these slashes at the end
here, these on a Mac terminal,

these show that we are in the new,

we're making a new line available here.

And also you'll see that there's

these account SIDs and these Auth tokens.

This dollar sign Twilio
Auth token, dollar sign,

Twilio Account SID, in my terminal,

on my Mac, that is what's known as an

environment variable and they've been set.

Now I don't have those set currently

because I just built this account.

So what I'm gonna do is kind
of bad practice actually,

I'm gonna actually put my

real information here for us to use.

So, back here on our console,

on our Twilio console you'll
see that I have this thing here

called this account SID
or String Identifier.

So this is my ID,

my unique ID for the
account that I just created.

So I'm gonna go ahead and I'm
gonna click this Copy button.

So I copied that, I'm gonna come back here

and I'm gonna move my mouse and I'm gonna

remove right here where
it says account SID.

So that's string identifier.
I'm going to paste this.

So that is the way that Twilio
is identifying who I am.

I'm gonna go backwards
through the rest of these.

And so if you're watching here on Windows,

let's just go ahead,
let's get rid of these,

these new lines here.

So I'm gonna just put
them all on one line,

we can handle that, we'll do that.

So I'm gonna get rid of
that line and that way

it will work completely on both Windows

and Mac for what we're trying to do.

So I still have my account SID here,

so I'm gonna keep on backing up here

and I'm going to get rid
of that line, there we go.

And you'll see one more time here,

there's the Twilio account SID,

that string identifier for
my account was still present.

So I'm gonna paste that there.

So now the API call that I'm doing is to

that specific account,
it's due to this messages

and you'll note that it's
doing, now it's doing a post.

So because we're creating
something new, right?

So we're using post to create a message

and you'll see here
that it says from equals

and the number actually there
for the from, we want that

to be the Twilio number
that we just got, right?

So that new one that we just got,

we're gonna say that is
sent from, let me go back,

I'm gonna copy my Twilio
phone number, right?

So I've got my 561 number there

and I'm gonna paste that here.

So you know from and this
plus 561, that's a US number.

So it's got the, it's called
a 10 digit long code, 10 DLC.

So it's (561)-816-5433 is the
number that I just bought.

And we're gonna say by
default it said, "Hi there,"

the body of the message, right?

So we're, instead of that,
whatever we're gonna do

and note that this is all in quotes

and we're gonna say, "Ahoy world."

I don't know if you know this
or not, but the first word,

the way that we used to
answer the phone was we'd say

the phone would ring and
you'd be like, "Ahoy?"

And the other side would go, "Ahoy-hoy."

So we like to do that here a lot,

at Twilio we say "Ahoy world."

It's kinda like the hello world of this.

So the body of the message,
the text that we're going

to get is gonna say "Ahoy
world" and then we're gonna

send it, I'm gonna send
it to my phone number.

So this is one of those
numbers that you verified

right when you created your account,

you verified that you had a number.

So my phone number is (432)-527-4274.

Don't text too late at
night please, and then

the final thing that we have
here is this Auth token.

Now this is a very private key, right?

We don't ever want anybody to have access.

This is like that Spotify
token that we had, right?

We don't ever want anybody to have it.

I am going to, I trust
you and I'm gonna go ahead

and I'm gonna paste that
here so that we have it.

So that is something that you never wanna

let out 'cause now you could seeing this

on my screen, you could use this, right?

And you probably don't
want anybody doing that.

So you never wanna actually
give that number out.

You wanna hide that and we'll talk

about how to do that
more here in the future.

But right now I just wanted to show you,

we're gonna use Curl,
we are going to create,

we're gonna send a post to this URL here

and you'll notice that ends in JSON.

So that's what we're gonna get back.

That's the way that it works.

This is to my account, my account SID,

you see it starts with this AC

and we're gonna post using
this data URL encode.

So the way that the Twilio
API works is it takes

some parameters, it takes from body and to

and the way that you pass those in curl is

with this --data URL encode and you pass

what it is that you want
to have go across here.

So we're gonna, if all of this works,

I should get a message back.

I should get a text message on

my actual phone that says "Ahoy world."

Let's do it,

and it looks like I'm
missing a quote someplace.

So where is the quote that I'm missing?

I don't see a missing quote.

I can go press the up arrow,
maybe it will show up.

Yeah. Oh, right.

You know how many times I do that?

The ahoy world, the exclamation point

is something that you
need to typically escape.

So I'm just gonna say "Ahoy world"

with a single quote there.

So, if you're having that problem,

sorry, that's what that was.

So I pressed the up arrow to
get my information back there

and now if all is going
well and I press Send,

we should get a text, here we go.

And so I got this message back, I got this

and sure enough, here it is, I got it.

And you can see here it says
at the front of the body

that it says it says, "Sent
from your Twilio trial account,"

which is fine, we're in a trial account,

that's totally fine, but I
did and boom, I got it on

my actual phone, I got that
message, which is awesome.

We now have the ability to send a

text message from the command line, right?

That's pretty cool.

Let's take this a step farther actually.

So we know that that
API, when I did a post,

I was able to get information back.

I'm gonna go ahead now and I'm
gonna do just bring that back

and I'm gonna get rid of all
of these parameters here.

I'm gonna get rid of the
from, the body, and the to

and I'm gonna change, I'm gonna make that,

I'm gonna do a get and let me
show you what that looks like.

So I'm gonna get rid of
all of those parameters,

I'm gonna keep that same
URL and it still has my

account SID there, right in
there and instead of a post,

what we're gonna do is
we're gonna do a get,

what we should do is we should get back

all of the messages that are there.

So I'm gonna hit this kinda
like a message log, right?

So these are all the
messages that have been sent,

which is awesome, here it is,

sent from your Twilio trial account.

So, and actually I can make this look

a little bit prettier
like we saw with JQ again,

totally optional in the
notes if you want it.

Yeah, there we go.

So you can see that I've
got some information

that's sent back here and
you can see that the message

that was sent in was sent
outbound to my phone number

to me from that number,
which is awesome, right?

And like I said, curl's
a little bit challenging

because it's gonna be
a little bit different

if you're in Microsoft
Windows or if you're in Mac.

I tried to make that as
comfortable as possible

but I you saw that I did
run into a couple of things

like I couldn't use the exclamation point

and things like that and
it's a little clumsy.

So stay tuned 'cause there are
more tools coming your way.

Awesome job getting that
running from your local machine.

It feels pretty good doesn't it?

What a cool skill you have now,
you can send a text message

from your machine with
just a single command.

Now believe me, this is just the tip

of the iceberg of what you can do.

There are so many more
Twilio APIs available

and now I know that you
can explore them with Curl.

For now though, let's take
things another step deeper.

Now I don't know about you
but I'm a little clumsy

when it comes to long
commands on the terminal

like we just did with Curl.

When exploring APIs, I really
like to lean on visual tools.

If you don't mind, I'd love
to show you some, that is,

of course, right after
you take a quick break.

(upbeat music)

There are a few tools that I
rely upon when it's time for me

to explore new APIs and I
thought I'd share 'em with you.

I used these to dive in and get

my hands dirty and organize my learnings.

One of the most famous
tools and one that you've

probably already heard
of is called "Postman."

Do you get it? Postman.

In addition to being a pretty good pun,

it's also a powerhouse of features.

Postman started as a Chrome
extension that let you

make API calls and what
it's turned into is

a powerful enterprise ready
tool with all sorts of bells

and whistles and even
shareable collections

for the most popular
APIs that are out there.

It's jam-packed full of features

and in my humble opinion,
you probably don't need

all that just yet in
your learning journey.

There are entire courses on
how to properly wield its power

and I've linked to a few
of those in the notes.

There are other tools
popping up all the time

that allow you to explore
APIs and store your notes.

I like to think of these apps as

the built in the vein of postman.

There's a whole genre of video games

that gets dubbed Metroidvania,

because they're similar to
"Metroid" and "Castlevania."

Now these apps are
Postmanvania, Postman-esque.

Let me show you an example.

I just bought this lamp here, it's rad,

it's from Govee and it's got this app

that I can use to control it on my phone.

I can change the colors, right,

and I can even make it
dance to my beatbox.

(Craig beatboxing)

It also has an API.

These are the docs here and
as I explore these docs,

I'm gonna save them in one
of these postman esque tools

that I've been using
lately called REST Fox.

Like here I can see all of the devices

that are associated with my Govee account.

And I set that up using
this URL here and you'll see

that it is a get request
and I pressed Send

and it sent the request and I got back

the Govee devices that are
associated with my account.

This API requires a header
and it's called Govee API key.

And you'll see these double
mustaches here that I'm using,

this side little mustache thing.

This is getting things
from my environment,

it's a special key that I
don't want anybody to see.

I'll show you more of those here in a bit.

Now notice how this is a get,

so I can send the request
and you'll see that here's

my response and I can also
get the current state.

So I have a different call here.

I can get the current state
end note that if I click Send

here we can see that this is
the color of my light currently

and I can also turn it on
or turn it off and I can

turn it on and I can also
change the color, right?

So I'm gonna turn this to red.

You don't have to turn
the red light on, Roxanne.

Pretty cool, right?

And I have this here
for me whenever I want

to tweak things, when I
want to come back later

and when I want to use it in my code.

Did you just have a light bulb moment?

I quite literally just did.

Let's see if we can't build one

of these for the Twilio APIs.

So if you'd like to
get REST Fox installed,

please check the notes.

This is an open source tool

and it's getting better every day.

Now if you love it too,

I highly suggest that you star it.

If you click up here,
you could go and you can

actually check out the
GitHub repo and you could

see cute little Fox here
and you'll see over here

how it's tagged that, oh
it's tagged REST client.

I guess maybe that's a little bit better

than my Metroidvania analogy.

Maybe REST client's a good thing.

API client, that's also a good thing.

So there's lots of these
tools that are available.

But let's start using this one.

So I've got REST Fox
running here and you'll see

I've got the Govee folder,
which I can collapse.

And typically what I do is group these

by the API that I'm exploring.

So let's keep poking around
a little bit with Twilio.

So what I'll do is I'll make
a new folder called Twilio.

So I'm gonna right click over here

and make a new folder called Twilio.

And now in here we'll
create a new request.

So I right clicked New Request

and I'd love to explore
more of the SMS API.

So let's see, oh you know what?

This new number that we just bought,

this Twilio number that we bought,

not only can it send messages,
but it can also receive them.

So we could send it a
message. So let's do that.

So let's go ahead and send
a text to your number.

Now if you forgot your number,
it's over in your console.

So if you come to your
console and you scroll down

a little bit here, you'll
see My Twilio Number.

So go ahead and send
a text to your number.

Now my number, I'm gonna send a number.

It's (561)-816-5433.
I'm gonna send it, "Yo."

And there we go, it went
and I ended up getting

a default message back
and we could change this,

we could make, we could
program this to do whatever,

but I'll show that off later, but for now,

I just want you to know that
we created a new message

by sending to this API and
we can actually get it.

And you can also find your phone number

later here under this phone numbers.

If you go to Phone Numbers,
Manage Active Numbers,

you can see your phone
number and remember outside

of trial mode you could
buy multiple numbers.

So that's an important thing to know here.

So, all right, so we are going

to look at the incoming messages.

So we should do that,

we should call the request
what it's going to be.

We'll call this incoming message log.

That sounds good. And we'll click Create.

Okay, so let's head over to the docs

and see how we might do this with,

so back in the docs here
on the message resource,

remember this is where we
did the create a message.

I'm gonna see if there's
something else down in here.

Ah, list all messages. That's a good one.

But we don't want all of the messages,

we actually want to
filter it a little bit.

So look here, we can do this
by matching filter criteria.

That's great.

So we're in here, I'm
under the curl tab, right?

I could be in these different ones,

but this is the example that we want here.

I'm gonna grab this URL,
you're gonna see all of this.

So that's how they're filtering it.

There's some stuff here at the end.

I'm gonna grab all of this
and I'm gonna copy it.

I'm gonna come back over and I am going

to paste it here in
this Enter Request URL.

I'm gonna paste the whole thing there.

And it was a get request
and the URL had some stuff

in this query string that came afterwards.

And a query string is, you know,

defined by this question mark.

So we don't want this date
sent, let's get rid of this.

And what's next? We don't
want from, right, we don't.

We wanna look at all the numbers

that were was sent to, right?

So this is the to here, is what we want.

Now this 2B here just
happens to be a percent

2B URL encode and happens to be a plus.

And I know that and I just happen to know

that without having to Google
it but that's a little rough

to know like how do I
make a plus sign in here?

Wouldn't it be nice if this tool just

did all of this URL encoding for us?

Like we didn't need to
make this mess at the end?

Well check this out.
Here's query right here.

This is what we want. So
we wanna add this query.

We don't want to have this
whole stuff at the end here.

We wanna put in to,

we're gonna add one of those things there.

We'll put in a to.

So that's gonna append
that query string for me.

And I'm gonna put in, to my phone number,

which again my Twilio phone number,

which is over here in my logs right here.

Actually I can, I'm
gonna grab this number.

This is my Twilio number.

I'm gonna put it in the format that

is wanted there in my
REST Fox, here we go.

So I'm gonna fix that and
we're gonna get rid of this.

Just wanna make sure
that's 1561, there we go.

Got rid of all those. All right.

Now also remember that this was accounts

and then it had account SID, right?

So that's the ID for my account.

And then it's under messages.

There's a collection called Messages

underneath this account SID.

But what we want here is we want,

that was using an environment
variable from Curl,

but this is also known as
a path variable, right?

A path parameter, so here,

down here we have this path parameters.

So the way that these work actually

to replace them is if we go like this,

if I get rid of this and I put a colon,

what's gonna happen is we
can, anything that's down here

in this path parameter
will replace what's here.

So let's do that. Let's add this item.

And again, that is Twilio account SID.

So that's the name of the
variable that's up here, right?

It's colon, Twilio account SID,
that was just what's there.

Let's keep it 'cause that's what it is.

And then we're gonna put
our account SID there.

So that also is on my console.

So I'm gonna flip back to my console.

And on the main page here, if you come in,

you can come down and you
can grab your account SID.

So now I have my account SID,

and I'm gonna paste that there.

Awesome, and I think we're ready.

I'm gonna press Send
an, oh, we got an error.

We got a 401 unauthorized,
no credentials provided.

Oh that's right. Of
course, we want to log in.

We don't want anyone just being
able to see these messages.

So we wanna make sure that we

have some authentication happening.

So I'm gonna head over to the Auth tab.

You'll see that if I
slide this back and forth,

I don't know how much
screen real estate you have,

but you can slide these
kind of around as need be.

So I can, I'm gonna
pull this and you'll see

that when I do my little
menu here collapses.

So I'm gonna choose Auth from here,

but that is also available
in the header here, right?

So like it's just a different view of it.

All right, so in the Auth I'm gonna put in

a basic Auth and I'm
gonna put in a username,

which is my username and
then I'm also going to put in

my password, which is
my Auth token over here.

And again, this is very private

and you would never ever want to do this.

You now know my Auth token.
I don't want you to have that

because you could do exactly anything

you wanted to to my account
now that we're there,

and one of the things
that you could do is see

the messages that were sent in and look,

there's my "Yo," my "Yo"
message has made it in, awesome.

So also I wanted to show you
the request that happened.

Let's take a look at that.

You can see that what
actually happened was it was

a get that was sent with
the account SID, right?

And so that was the account
SID that we used from,

if we look back at the
query parameters here,

the account SID showed up
there and then it automatically

did a two URL encoded
and if you look it put

the question mark in for us
and it did that percent 2B

for us automatically URL
encoded, very nice, right?

And we can see the headers that were sent

and we can also take a look.

Let's look again at this preview.

So we see that we had,

the response came back
and this is JSON, right?

So we have a key called messages.

And this messages has this, it starts out,

there can be multiple
messages here, right?

So this is the start of what's known as

a list or an array and
then there's an object.

And the start of the object
is always done with one

of these mustaches, and
we call those mustaches

'cause if you kind of
turn your head sideways,

it looks like a mustache.

So all between the opening
mustache and the closing mustache

is the information about
the messages, right?

So here's the, and there's
the closing bit of my list.

There's only one. This is
the closing mustache there.

And so part of the
message that we can see,

we can see who it was to,

that's my Twilio phone number here.

And we could see the from,
there's my phone number there,

please don't call too late,
but that's my phone number.

And I did say, I said "Yo"
to it, which is awesome.

So now we have this. Now this
step is completely optional.

This is something that I like
to do is I like to take notes.

All right, so there's
this incoming message log.

I like to keep notes and I put those

in the description over here.

And so let's see this
returns all incoming.

Well, let's be a little bit more,

all messages sent to
this phone number, right?

And one of the things that I like

to do is I like to put on the docs here.

So if I ever come back and I want

to find how was it that
I learned how to do that,

I can go and look and put a link there.

So I'm gonna go flip back
over to the docs real quick.

And this is read a message
with matching a filter.

I'm gonna copy this
link, I'm gonna grab this

or click this here so that then
it changed the URL up here.

I'm gonna copy this and this is

what I'm gonna store in my notes.

Again, this is totally
optional and this is just notes

for you for later 'cause
you could end up having

a whole bunch of these and you might not

remember how you found how to do that.

If there's something specific or strange

about the API that she wanted to know,

I keep the notes in there and it's a just

a handy learning tool and
again, totally optional.

So we've got our first entry all set

and I think we should add another one.

Why don't we create the
send message one, right?

So the one that we did before

we sent messages, let's do that.

So I'm just gonna duplicate
this 'cause it's got

a bunch of the information
that I already need in it.

So I'm gonna duplicate it and
what I'm going to do here is

I'm gonna duplicate and I'm
gonna say "Send message," right?

So when we sent a message before,

remember it wasn't a get, it's a post.

So I'm gonna change,

I'm gonna change that
from a get to a post.

So now we've got this send message

that's a post and the query string.

I don't want to send a
query string anymore, right?

So remember wait, before when we did this,

we sent it to using the data URL encode.

In fact let's go, let's
pop back over there

and look at what it was that we did.

So in the documentation over here

we have this create a message resource.

So, on the message resource
page here, we can look

and we can go to this
create a message resource

and there's some information about it.

So you send this http post
and you can see that again

we were, remember before
we were doing this data

URL encode and we were
doing this URL encoded.

So it's this form encoding
is what's happening here.

And oh look, well a couple things

actually there's a nice warning here.

This says if you wanna send messages

while in trial mode you must
verify your two numbers.

So if you wanted to send to somebody else,

you could put them in
this verified caller IDs

if you wanted to, you could
send to somebody else as well.

Just there. That's how you do that.

If you wanted to test or show somebody

what you're building,
that's how you do that.

After of course, after
you're not in trial mode,

you could submit to
whoever you would like to.

So when we are creating a message,

we must include the to, right?

We need that and we need the from.

So we'll do either and
we'll do body and there's

this media URL which means
I can send a picture.

Let's do that. Let's make it
so that it sends a picture.

Now when I am in REST Fox over here,

I don't want to use the query anymore,

I'm gonna keep the path 'cause
the path is the same, right?

So we're gonna do, we're gonna
do a post to that same URL,

Twilio account slash account
SID messages dot JSON

and we're gonna make a post
to it instead of making

a list and retrieving,
we're going to create.

So we're gonna go under
body and for the body

we're gonna make it form URL encoded.

And what we wanna do there
is we wanna send it to,

so I'm gonna send this to my number.

Again, don't call too
late, (432) 527-4274.

No really, if you wanna call

and get feedback, that's
fine, I'd love to chat.

So we'll do from, and
that is my number again,

this is my number and
which was that number.

So we can come here into the message log.

We can go pull that number
from the query string.

So this is my Twilio number there.

From is this value there and we are going

to add the body, the body will say sent

from REST Fox and let's add our media URL.

And I just happen to have
one of my favorite photos,

which you will have to check out

for yourself to know what it is.

But it is a photo that
I pick, if you will,

that I'm going to send to myself.

It's also in the notes if
you want to do this as well,

if you wanna copy that and paste that.

So here we go. I am going to do a send.

Now remember I'm also
authenticated with my username

and password 'cause that
copied across when I did it.

So I'm gonna do a to, from,
a body and a media URL.

So now I'm gonna go ahead
and click Send and boom,

we got our message back, right?

So the response, we got
a 201 created, right?

So it was created in the body,

we can see the body of our message.

The key is sent from REST Fox,
it's got some information.

We can go ahead and get
access to that message

if we wanted to and it's got
these actual media resources

down here, which we can
also take a look at.

And we could, if we wanted to
open up a whole 'nother one

of these and explore and
see what that looked like.

But let's take a look
at that in a new tool.

Before we do go to look at that new tool,

one thing that I don't
love about what we just did

are in my, in these requests, in these

separate requests, these
are duplicated, right?

I've got this username and password.

If I go to my post send message,

I've got this username and password

and they're duplicated there,
which isn't great, right?

That's not excellent.

One of the things and one of
the tools that most of these

REST clients provide is a
thing called an environment.

And let's set that up really
quick, real quick for this.

So if I come here under this environment,

here is my default
collection and I can add

a new environment, I'm
gonna add one for Twilio.

Now the way that these work
are, they are JSON based.

So this is, remember this
is the start of an object.

Now if you've never written JSON before,

take your time, use some patience.

One of the things that you
could do is you could come in

and you can put in account
Twilio account SID,

and you do the key and then you do a colon

and you can see that
I'm, this is unexpected

JSON down here, it's helping me out.

And now I'm gonna put in
my account SID and again,

let me go copy that one more
time and I don't have to copy

this anymore 'cause it will
be part of my environment.

It will be here with me,
which is really nice.

So come over here, I'm gonna paste that

and now I want to add a new key.

So the way JSON works is you
put a comma after that, right?

And I'm gonna put a new, the new key here

and we'll do a Twilio
account or Auth token.

And again, this is, that can
be, that key can be whatever

you want it to be and we'll
be able to reference it.

So I'm gonna come and grab my Auth token

and I'm going to change this, right?

So that's a great use case
of this is I don't want you

to be able to, I am going
to change this, right?

So as soon as this, as soon
as I'm done recording this,

I'm gonna change my Auth
token and that would mean

that I'd have to go
change each one of 'em.

But now I have one place
where it's defined.

I have one place in my
environment that's defined.

So I have this environment
here that says Twilio.

Now instead of username I can
do this mustache, mustache.

And I can say Twilio account SID

and that's the way the
templating language works here.

And then most of these REST clients

and you can do Twilio token.

So when you see that's what's happening.

That is the environment,

it's using the environment variables.

I'm gonna go do that for here.

And also I'm gonna copy
my Auth token for here.

And so now I only need to
change that in one place

in my environment and
you can also use it here.

So like not like before I can,

I can also put my account SID here.

So that will also make this
so that it's shareable, right?

So if I don't specify my information

in here, I can share it.

So you what you could do, and
actually why don't you try

to do it, why don't you try to
add your Twilio phone number

and see if you can figure out how to add

to your JSON there,
your Twilio phone number

and then you could replace it, right?

You could replace it here with your from,

from your Twilio phone
number, pretty neat, right?

So that's a good, little trick
that you could do in here.

You could do your Twilio phone number,

you could use it there too.

So anything that you're using is something

that you can kind of store
there in your environment.

And what's nice about that,

let's make sure that it still works.

Yep, it's still working.

And let's make sure, make sure my, oh,

I'm not gonna send another
picture to myself, that's fine.

So we know that this
environment is now working

and it's here and I don't need to go back

and get those every
single time, really handy.

And what's nice is you can
do these imports and exports

and we'll take a look
at that here in a bit.

So when we get back
we're gonna take a look

in a different tool
'cause this is REST Fox

and I know that you're probably
getting ready for a rest.

So let's take a quick break
and then let's see if we

can't retrieve that pic that
I sent myself via this API.

But let's do that in another
Postman mania or REST client,

right after a quick break, that is.

(upbeat music)

All right, quick refresher.

We had just sent a message from
REST Fox, a REST API client.

Here's the body of the message
we just sent from REST Fox

and we actually sent
across some media with it.

You can see here it has
this Num Media one 'cause

each text message can have
multiple medias attached.

And if you scroll down here,
you'll can see that there

is this key of sub resource
URIs and it has a list

of an object here and one
of the objects is for media.

And what this will do is
this will allow whatever's

at this URL will give us the accounts

for this account, for
this message specifically,

it'll give us all of the
media that is listed.

Now, typically when I have
something that's this far out,

we could actually add another one here.

But I thought I'd show you a
little bit of how my process

normally looks in case we wanted
to see what that felt like.

So I use an editor called
Visual Studio Code.

It's free, it's available

and this is where I do my coding from.

So I start here, I start
working on my coding.

I would love for you to
go ahead and download this

because I wanna show you
a tool that's inside here

that will allow us to do
a REST client as well.

So go ahead and pause me, get
Visual Studio Code installed

and when you do come back
and I'll show you something.

(upbeat music)

Okay, so once you get
Visual Studio Code up

and running, if you press Command+Shift+P,

there is a thing called extensions.

And this will do a little, if you type in

Install Extensions, you can come here

and you can see different
things that are available.

What I want you to install
is a thing called Thunder.

We're gonna do install a
thing called Thunder Client.

And it's this one here,

it's a lightweight REST
API client for a VS code.

It's really powerful and the good news is,

is it is Postman-esque.

You are gonna feel very familiar

when you take a look at this.

So if you do it, you can
go ahead and click Install.

And what will happen is there'll
be a little Thunder Client

that will install over here like so.

And just like you've seen
before, there are these,

this concept of collections
and we can make a new one.

So I'll make a new collection
for Twilio and typically

what I'm doing is I'm coding
and I run into this API

and I'm like, ooh, I wonder what this is.

I'm gonna go explore it a little bit

and I'll explore it right
from my editor, right?

So I'll write my code here
and then I can come over here

and just take a look at what was there.

And so let's go back to
REST Fox and I'm gonna grab

that REST Fox that we had here, right?

So we're gonna do that.

I'm gonna grab that and I'm
gonna come back over here

to Twilio, I'm gonna make a new request.

I get to name it. And
this was the media check.

Let's no, we're gonna do all media.

All media for a specific message, right?

So here we go, I'm gonna paste that URL

in here and of course it's missing

that first part, which was api.twilio.com.

So again, this is the going for

that account to those messages.

I'm gonna look here at where it says Auth.

So it says inherent
authentication values from parent.

This is a very nice thing and
this is something that Postman

has too that REST Fox
doesn't necessarily have.

We put this in our own
environment, it's kind of similar,

but you can make, for this
collection that we built,

we can actually do the
settings for the collection.

And if I come in here,

I can set the Auth up here so I could do

this basic Auth here and go grab my stuff.

And so just a reminder
in REST Fox, when we did

that before we were in
the environment of Twilio

and I was able to grab the
Twilio account SID, right?

So let's go back to our code
here and the Twilio account SID

is the username and the password.

Let's go back to that
environment in REST Fox.

The password is that Auth.

There we go, we'll paste that there.

Perfect. So I'm gonna click Save on this.

And so now this all media should work.

So I'm gonna go ahead, I'm gonna do

a send to this and there
we go, we got it back.

And we can see there's a
media list is the key here.

And again, it's an array of those and this

is the list of all of the
media that's available.

And so now look at this collection.

So we have a collection of accounts

and here's a specific account.

We have a collection,
that account has messages.

That message has media and
that media has an entry,

a media entry, and that's it.

This is what we're looking at right here.

So something that's pretty cool.

The way that this works is if I get this,

I can get some metadata
information about it.

But if I get just a little bit of it,

if I just go ahead and
take this the way that,

the way that Twilio works,
and not all APIs do this,

but if I do this without
the extension here,

I'll actually get back
the picture that I sent.

So I'm gonna do that,

I'm gonna make a new little request here.

So a new request, and we're gonna

call this, get the pic, right?

We're gonna get that pic that I sent

'cause we don't, still don't
know what that pic was.

What was it? Let's go take a look.

So, again, at the end
of this, oops, sorry.

At the end of this, there
is no extension, right?

So I got rid of the dot
JSON extension and I'm gonna

put it the front here,
HTTPS api.twilio.com.

And the interesting thing
about this is this pic

is not authenticated and
if you do authenticate,

you end up actually having some problems.

So I'm gonna tell this
request specifically

to not inherit value.

So I'm gonna disable this so
that it's not authenticated.

So when I click this, if all goes well,

we should see the pic that I submitted,

awesome, and we do, cool.

So it's a little big,

it's a little big of a
pic that was sent here.

And we could take a
look at some stuff here.

We could look at the
headers that were sent.

So we can see a couple things.

One of the things that I
think is really interesting is

when it says last modified,
so the last modified date,

if you have a request that has this on it,

it means that you can use caching.

So you can, when you make the
request, you can actually say,

if it's been modified
since this time, do that.

So I'm gonna do that, I'm gonna grab this.

Let's just take a look
and see what that does.

So I'm gonna go to headers here

and I'm gonna put a new
header in here of if,

and you can see that
there's auto complete.

So it's if modified since.

So again, this is the
request that I am making,

I'm making this request and
I'm gonna say if it's been

modified since then, give me
and otherwise let me know.

And so the way that it lets
you know is 304 not modified.

So that's a status and you'll see

that I got zero bytes back.

So that is how caching works

and what you can do to send this across.

So, this is really powerful, right?

I didn't need to set up
all the other things.

And it's kind of really a
quick little look at this.

I don't actually even
need to do a collection.

I can just do a new request
outside of it and I kind

of explore through and see
how these things are working.

Which ding, ding, ding,
means we covered another part

of a RESTful API
constraint scavenger hunt.

Using standard HTTP caching

mechanisms like last modified and e-tags,

a RESTful API should support caching.

It's up to you to maintain
the cache on your client

and decorate requests,
but this can come in

really handy to avoid
making unneeded requests.

And those are the Postman-esque
things I wanted you to see.

I wanted you to be able to
do that without diving in

necessarily to do all of the
Postman enterprise things

that you wanna do, but I think it's time.

I think you should feel
comfortable enough that we can now

look at Postman and see what
we've already learned there.

So I'm gonna go here and
I'm gonna just do a quick,

quick little Google search for Postman.

And this is really nice.

You can do this for whatever
API you're working at with.

And since we're working with Twilio,

I'm gonna search for the
Postman Twilio collection.

So there's some docs on Twilio about it,

but if you look here,

there's this Twilio
Postman on the API network.

So this is important
to know, there's a lot

of things on this API network where

they've built APIs for
you to go and share.

So I'm gonna click this and now note

I'm inside of a web browser.

Postman's done a really gorgeous job

of letting you run inside of your browser.

You also can run it locally
like we did with REST Fox,

but I'm gonna run this from my browser.

So I'm gonna go into this
messaging SMS and you can see

there's all sorts of
different things in here.

It's a little bit hard to get to here,

but you could change things.

Put in your account SID,
and all sorts of things.

Like we saw, look, here's
the double mustaches, right?

And here's a thing to send
an SMS and it's super cool.

It's neat, right? And so you've seen this.

Here's your authorization, the headers,

the body, there's collections.

And what's cool is somebody's already

built these collections for you

and they're sharing your
stuff this way, right?

So that's kind of nice.

So there again, there's
path variables, right?

And the path variables coming up here.

There's the call and
account SID that you saw

from before, here, somebody's
using this as the start,

the https API twilio.com and
it's doing a post, right?

So it feels very similar. So
you're familiar with this.

There's also a bunch of other
things over here that it

can do that could get a
little bit distracting.

And that's what I was
trying to kind of avoid

'cause I wanted you to
get familiar with it.

But know that this exists.

One of the really cool
things that Postman does is

if you click over here on
this far right over here,

there's this little code,
it's like open and closed tag.

This is really neat.
So we have Curl, right?

So we could see, this
is how I would go ahead

and do this and this, this
feels familiar, right?

This is how what we actually did,

we did this curl statement,
but check this out.

You can do this in any
programming language.

So the trick here, the
trick to remember is that

any programming language that
can make an HTTP request,

like it has a client built into it,

because these are all
standard, the REST API, right?

We're following these constraints that

have been defined, it can
generate code for you.

So here's node JS using
a package called Axios.

So Axios allows you to fetch things.

So this is what it would look like

if you tried to write that using Axios.

And if you look in here,
you come down here,

here it is in PHP with Guzzle,
I don't know what guzzle is.

I like that though, that's why I chose it.

So you could see that it's
generating this code for you.

And if I copy this and pasted it into

my PHP code or my Python
code or my Java code,

it would just work and that's really handy

that is if the company that's
providing the API doesn't have

a helper library or an SDK,
a software development kit,

which we haven't looked at
yet, but we're about ready to,

Twilio does have one of
those but if you were

looking at one of these that didn't,

this is a great way to get that code.

So again, check out the API network,

this Postman API network, it's cool.

I think you're ready now
to use this if you want to.

But also feel free to use the other tools,

explore the APIs in a comfortable way,

wherever you might be
most comfortable with

'cause there's all sorts
of really fancy tools here

on Postman and like I said,
there are courses on how

to take full use of all of
the things that are available.

Awesome job diving into
all those tools, Postman is

a super powerful tool and it
keeps getting better every day.

There are so many features
that we didn't cover.

We barely even scratched the surface.

There's an entire course out there on it.

Check the notes for a way to see that.

We saw how to organize
our request together

into collections as well as share common

and secure values by using variables.

We learned how to add
different values to request

both informed values,
query strings and headers.

And we also saw how to navigate through

various sub resources via clicking URLs.

We even saw how to create
actual runnable code from

your request, while we were
in the Twilio documentation,

you might have noticed the code examples

on the screen on that page.

It's possible the tab
between various language

implementations and solutions.

Many products offer
what is known as an SDK

or software development kit
or helper library that allows

you to interact with their
product in your native language.

As you can see, it abstracts
away the REST API completely.

Let's take a look at the
Twilio helper library next.

Before that though, just a quick reminder

to make sure that you check
the notes on this video.

There's a link to a repository
of built out collections

that are ready for you to use.

There are lots of great
APIs to practice with.

All the tools that we just looked at

are great for accessing
and exploring APIs.

However, when it comes time you're

most likely gonna wanna write some code.

Now as we saw in Postman,

you can actually generate code.

All programming languages
have some sort of way

of making HTTP requests and
as you know, HTTP requests

are all we really need to
interact with REST APIs.

So writing that sort of
code is totally fine,

but you'll find that
you'll end up writing a lot

of what is known as boiler plate code.

By boiler plate I mean
code that is repetitive

and almost always the same,
just with a few tweaks.

Many products and services have created

a solution to help you avoid this problem.

They're often called helper libraries

or SDKs, software development kits.

They'll be specific to
your programming language.

These libraries help make your code

more concise and legible.

They usually also provide
additional documentation

for your editor, which I find super handy.

Let's go check out some
of these helper libraries.

Okay, so let's take a look at
one of these helper libraries.

Let's take a look at the
first one that's here.

So again, I'm in the docs SMS,
create a message resource.

I'm here under the curl
tab currently, remember,

when we did this, we went
and we saw how to do this.

We passed the from, the
body, and the to, we passed

in these environment variables
as what this dollar is.

And this dollar Twilio Auth token,

their environment variables

and it's also used here in the URL.

So we had done that, we
had done that with Curl.

Now one of the really nice things about

these helper libraries is
they look very similar,

but it's taken away this whole notion.

So let's go here. I'm
gonna go to this node JS.

Now, quick word of warning,
if JavaScript is new to you,

there is some stuff here that
might be a little confusing.

And I want this to just
kind of wash over you.

I want you to more feel what
it feels like as I explain it

and don't be too concerned
with not exactly understanding

all of the things that can
happen, especially if you're one

of the folks who has the
Hello World requirement.

Please don't feel like you need

to fully understand all this.

I will walk through this code
line by line and tell you

what it's doing and it
will be familiar to what

we've been doing just in
a programming language

that you might not yet be familiar with.

So I'll take my time
and you take your time,

give yourself some patience.

In fact, I'd like to
suggest that if you are in

the boat where you have
not written code like this

before that you watch me
first and then come back

and do it later, we're
gonna take advantage

of the fact that we're in a video, right?

You can take me right back to right here

and take me back to right
here and we could get started.

So one of the things that I love about

Twilio's documentation is that you can

just copy it and it should work.

So this is what was happening when

we created something here, right?

So we created a message.

So this is, you get this
authenticated client, right?

We know what that is.

We authenticate with our
client, with our account SID

and our Auth token like we've been doing.

And then we're gonna do
this messages, a client.

So client.messages,
there's our REST client,

.messages.create, and we're
gonna pass in the from the body

and the to and it's got all
the information that we know.

And then there's doing some
of this JavaScript stuff.

So then we're gonna get a promise back

and then we're gonna get
access to the message.

And this console log is going
to print out to the screen.

I don't think we should send a message.

Why don't we look at the
messages that we've done?

Let's do that. So I'm
gonna go to that example.

So I'm gonna choose down
here, this list all messages.

Awesome, so we'll take a look at all

of the messages that are in the account.

Now what I can do is I can just copy this.

So I'm gonna copy this

and I'm gonna run it on my local machine.

Now I'm just exploring,

and this probably happens
as you're looking at APIs.

So typically I have a folder
on my computer called Scratch.

And if you wanna make
one, you do Mkdir Scratch.

Just kind of put this
wherever you want to.

And then you get into that directory.

If you're doing this in
your terminal on Windows,

there are some instructions in

the notes on how to do exactly that.

So now I've got this
directory named Scratch.

Now I told you before I was
using Visual Studio Code,

which I hope that you have installed.

And so I'm gonna do code
dot, and if this doesn't work

for you, there are instructions on how

to get this installed
properly on your machine.

What it should do is pop open

my Visual Studio code
directly in that directory.

So I'm in this directory here

and I'm gonna make a new file here.

I'm gonna call it explorer.JS

'cause this is typically what I do.

So I'm gonna come in here and
I am going to paste that code.

Awesome, so now I have this code here

and this code is on my local
machine, which is awesome.

So now I'm gonna try
to make this code run.

Now one thing that I
know for sure that I need

to do is I need to download
the Helper library.

So if I wanted to go here, I
could go to this node install.

I happen to know how to do that.

So I'm gonna go up here under
terminal and I'm gonna do

New Terminal and in Visual
Studio Code, this is really nice.

My terminal can actually run
the same terminal that I used

to open it is running
down here in the bottom.

And what I'm going to do is
I'm gonna use a package manager

to install the Twilio Helper library.

So I'm gonna say NPM Install Twilio.

So NPM is node package manager.

And if you do not have
this, if this does not work,

check the notes because it means that Node

is probably not installed
on your computer.

And if Node is not
installed on your computer,

there is a great walkthrough in the notes

on how to get Node installed.

So I now have Twilio
Helper Library installed,

which means this required Twilio statement

here is requiring that library.

Remember in REST Fox how
there was an environment

and we stored the account
SID and the Auth token?

We can do the same thing
on our local machine.

We can set up a little environment here.

And actually if we go ahead and we click

this Twilio Secure,
there's some great examples

in here and how you could do that.

So one of the things
that this suggests doing,

you can see it's for Mac
and Linux and different,

different shelves do different things.

If you run this in your command line,

you can set your environment variables

and then when you run Node it will work.

I'm gonna do, I'm gonna do this one.

So I'm gonna copy, copy this here

and I am going to just paste this.

We'll paste this, I'll
show you what it does.

So it's saying we want
to export my account SID

and my Auth token just we're
very familiar with these days.

So we're gonna do that.
Let's do this real quick.

So I'm gonna pop in my
account token there.

I'm gonna go back over to my console,

scroll down and grab my account here.

And then I'm gonna paste
that and I am gonna go

and grab my Auth token and
I am going to paste that.

So again, I got to that,
oops, accidentally pasted

my Auth token in the wrong line there.

So I know that it started
with a four and I'm gonna

paste it down here where
it says Your Auth Token.

So basically what this is
doing is this is writing

a new file that will
have this information.

I'll show you that here in a second.

So there's my, it's gonna
write these two lines.

I'll show you what that looks like.

So it's gonna create a new
file called Twilio.env and then

it's gonna append that that's
what this double --Twilio

and then it's gonna source that,

which means run that environment variable.

So if all is working
well, now if I say Echo

and I can do Twilio
account SID, we can see

that I have that
available and that created

this file here called Twilio.env and you

can see there is my
account SID and my token,

which is nice because now this code works,

it should be working and using this.

And in fact if all is
going right, so I've got

Node installed, I installed
the helper library,

I put my account SID from the console into

this Twilio.env and then I
did this final command here,

the source Twilio.env
which will run that file

and put those variables into
my environment variables.

And as I showed you
that they were working.

So let's go ahead and
let's do node explorer.

So what's gonna happen, let's
take a look really quick.

I'll show you, let's see, let's
make sure we got it working.

Cool, we did so let's walk
the code really quick.

So this is pasted
straight from those docs.

So we're getting a client back
from this required Twilio,

this is a Twilio library and when you get

the Twilio library, if
you pass it in account SID

and an Auth token, it'll
automatically create

a brand new REST client for you, right?

So this is a client that you're able

to use to hit the REST API, a Twilio.

And because it knows who you are,

it's able to access stuff on your behalf.

So very similar to what we
were doing with the Curl,

but this client, we can
use this multiple times,

it will always be authenticated.

So we're saying of all of the messages,

we want to list them, right?

So we wanna get a list
of all of the messages,

actually not all of
them, only 20 of those.

So let's go ahead, I'm gonna just,

we know that we haven't sent
20, I'm gonna get rid of this.

So you can kind of just
see this other style here.

So we're gonna say of those,
we're gonna do this list

and then I'm gonna bring
this back a little bit

here so you can kind of see, let's change

the structure of this a little bit.

So we'll say client messages

and then we're gonna do a list on those.

Now the way that this works
is this is asynchronous.

So JavaScript is asynchronous
and if JavaScript

is new to you, you probably haven't

encountered its asynchronous behavior.

What we're going to go
over here might very well

be overwhelming, but
it'll make sense someday

if you stick with it, I promise.

Now I've added notes, but
really please, please,

please, please do not
let this stress you out.

I just want this to go
over your mind about

what's happening here and
it's important to understand

because our client here, these
list methods are asynchronous

that which means that
it's gonna go and run Auth

and do some things and then
it's going to come back.

When that comes back,
it's gonna run this code.

So this is how a promise works.

So it's going to say then
after you go and make

that request, then give me
the messages and just so you,

what's kind of strange about that is if

you're probably used to
code working like this.

So I'm gonna write out to the screen

that's this console log.

I'm gonna say Starting Program.

And we should see that line print.

Now you might think that
this is going to print,

it's gonna run this and
then go, but if you,

I'll show you here, if
I do this console log

and I say gathering message
log, what you'll see is

it's gonna say this,
this line's gonna start,

but immediately it's
gonna go to the next line.

So let's do that. Let's
run that one more time.

I didn't save it. So of
course it won't do anything.

So you can see this little
dot here in visual studio.

It didn't save, so I'm gonna save that,

run that one more time, here we go.

And you'll see right away it's

a starting program gathering message log.

So it ran this, but then
it went down to here.

So it did not wait because
this is asynchronous.

What's happening here is
asynchronous and what's happening

is client message list returns a promise.

Now it's a promise that
in the future there

will be a value and
that value is messages.

And so the way that you
write that code is this

then waits, it defines a function here

and as soon as this is done,
it will run this function.

As soon as they come back,
it will run the function.

So that's what happened, right?

So it came, it started,
it then ran the function.

And when I say function,
you might not have seen

this before, but in JavaScript
you can make a function.

I'm gonna put parentheses here

so it's a little bit more clear.

These are the parameters for the function.

And this fat arrow is saying, this is

what happens when the function runs,

this like little, they
call it the fat arrow.

It's kind of cute, right?

So it's an equal sign
and then a greater than,

it's called a fat arrow and that's a way

of quickly defining a function
and so you can see here,

there's another one here
that's doing it as well.

So it could be a little bit
messy as you're looking in.

See how all these parens
that we're looking at,

it's kind of kind of hard
to understand and read.

If this is your first
time looking at that,

I totally feel for you
and so this messages

that comes through here is an array.

So, what was very nice is it
came across this messages list.

This is an array, it was a
JavaScript array by itself.

They have this method
called For Each on it.

And it will let you loop
through each of the values

that are in an array and
you'll notice that the object

that was inside of that
array has some properties.

So what happened was the client
went and made the request,

made the http request, it got
back that JSON that we saw.

Let me just go show you one more time.

Let's make sure that we're
looking at the right thing here.

So we, this is the same
code that we just saw.

This JSON was returned, right?

This JSON was returned,
but what the client did

for us was it inflated
these into messages, right?

So these are, this is a string of things

and it came back JSON but
I'm able to actually work

with each of these messages
as if they're an object.

So let's look at that again.

So list returned this object,
this array of messages

and each one of those in that array

I'm able to use an array method for each.

And this message is an actual object

that has a property called SID.

So again, if that is all
new JavaScript terms to you,

don't worry too much about it.

Basically we went and got
the messages and we showed

the messages that we got,
that's what this is saying.

One of the things that
I want you to be careful

of as you're looking at
promises, and you might see

this sometimes as you work
with APIs, 'cause oftentimes

APIs that you hit are going
to be asynchronous like this.

You might see that you need to be able to,

you might run into an error

and what might happen is
it might get swallowed.

In fact, let me cause one to happen.

So here it's supposed to say Auth token,

I'm just gonna put in my luggage,

the password to my
luggage 1, 2, 3, 4, 5, 6.

So that is not my account
SID that is going in there.

So I had the wrong account SID.

So I'm gonna say that
hey this is the client,

this is what how I want
you to authenticate

and it's gonna go to try to
make this and it's gonna fail.

Let's see what happens when it fails.

Well I didn't save it
so let's save it again.

Boy that's a lesson that
I really hit in the home.

You gotta make sure you save your file

or the code doesn't run.

So let's do it again, and
you'll notice that I didn't

get any error at all and
that can be confusing,

that is something that is very strange

because obviously
something wrong happened,

I didn't get any of the messages back,

but it doesn't look
like I had any problems.

So what's happening 'cause
this is running asynchronously,

this then never runs, right?

We never get a chance to run this 'cause

this list method didn't
actually finish working.

So one of the things you always
wanna make sure that you do

is to every promise you can
catch and you can catch an error

and I'm gonna make a fat
arrow 'cause I'm gonna have

a function happen here that
says console dot error, E-R-R.

Okay, so now I'm gonna print that out,

I'm gonna print out the error.

Let's run that again,
let's see what happens.

Ah, now we see the error and you'll see

that sometimes this is what comes back

is there was an
authentication error, right?

And we got a very specific
error on this 2003

and it will help us kind of
look at what's happening.

Oh, here, great. This is right.

My Auth token is wrong,

the wrong combination of
account SID and Auth token.

Exactly. That is what has happened.

So cool use of things there.

I'm gonna put this back so
that we have things working.

So this was Auth token

and I can still leave my error in there.

I'm not gonna hit an error,
so it's not gonna happen.

So a promise has a then and
it also has a catch, right?

So let's do that.

So I'm gonna run that one
more time and save it.

Wow y'all, I gotta get
better at saving. Here we go.

There we go. So now we're back
to working again, awesome.

All right, I wanna show you a little bit

of a different way that
JavaScript can work

asynchronously that you might also see.

And this is really syntactical sugar.

It's called async a weight

and if you just wait a
bit, it'll all sink in.

I promise that's a, there
was three jokes in that one.

That was a hat trick of a
joke. All right, so here we go.

So the way that it works,
the way that this works is

you can say that a function
is going to be asynchronous

and we want this to run
asynchronously, so I was thinking

we're getting ready to
start using our number in

an application and to get
there we need to clean it up.

We have a bunch of weird
messages in there that aren't

gonna be relevant to the
messages that we have.

So I'm gonna make a new
function and I'm gonna

call it "Delete All Messages," okay?

And when you define a
function, you can kind of put,

this is the parameters that it takes.

We're not gonna say that,
there are no parameters.

And then I'm gonna run this function.

So while this is an asynchronous function,

I can actually make it look
more like it is in line

so it can kind of run the
way that we want it to.

So I'm gonna say "const
messages" equals await.

So now I have, because the
function itself is asynchronous

'cause I've used this here I
can use this keyword, await,

and I'm gonna say client
dot messages dot list.

And so now I think this is a
little bit more clear, right?

So this is basically doing
the same thing, right?

These messages are the same
messages that were coming

into this function, but
now it's out on this side.

So I have this variable
that's called messages.

So, and that's in array, right?

And I could do this exact same thing here

and I could list that the same way.

But let's go a little bit farther.

So I'm gonna say for each of the messages,

for each message that is
of the messages array.

So these are those inflated
messages that we saw.

One of the cool things
that you're able to do

with the client is the
object that's returned back

has actually has some properties on 'em.

And one of those properties
that it has is called Delete.

Before we do that, I'm
gonna make sure that,

let's do a warning here real quick.

So I'm gonna say console
dot warn, we're gonna say

would have deleted,
I'm actually gonna use,

if you use these back ticks,
this is kind of a neat trick.

You can use this back tick
to do string interpolation.

So we'll say would have
deleted message dot SID.

So again, that's the
string identifier of that.

So would've deleted message dot SID.

So, and we will close that
function out. All right?

And now I'm going to call
that function in this,

you know, of course that's how we call it.

And this is would actually be a promise,

this would be a very
similar, so we could do this,

we could do a then, well
in fact let's do it,

we'll say then, and if you wanted to call,

make a function that has no parameters

'cause I'm not returning anything, right?

I'm not returning anything
from that function.

I'm just gonna say console dot log.

And I'm gonna write done
and I will put all of these,

this code into the notes
so you can also copy

and paste it if you want to.

And I'm gonna do the same
thing that I did before.

Catch the error and I'll do
will do console dot error.

And now if you do the
console is, you know,

of course what's running
when the program runs,

it's running out to the screen
and there's different levels

that you can do and error is one of those.

And if I just pass the
error that happened there,

so I'm gonna warn that we would've deleted

the message but let's take
a look at what happened.

So I'm gonna get rid,

I'm gonna keep the starting
program here, right?

So we can do starting program

and then it's gonna do
delete all messages,

it's gonna call that and
then when it's all done,

it will say done, I'm gonna
get rid of what we had here.

Okay, so we have delete all
messages, it's gonna go in,

it's gonna get a list
of all of the messages.

It's gonna loop through
each one of those messages.

And when it is done, we're gonna,

right now we're gonna warn
that it's would have deleted it

and this is what we're
eventually going to do

because there's a function
that's available to it.

All right? So I'm gonna
save that, I'm gonna run it.

Let's see what happens. Okay?

So it would've deleted some of our SIDs.

And again this is the
MM, this is, the MM means

that it was the MMS which is the one with

the picture and the rest
of the SM's that we have.

So I think I am ready to do this.

I hope that you are
ready to do this as well.

Again, this code should
you want it is available

in the repo 'cause you want to run this

'cause you want to delete these messages.

So let's, I'm gonna
say, I would've deleted,

I'm gonna say deleting
and then here we go.

I'm gonna save that, I'm gonna run it.

And so message, the message
object that's coming back

from this client is really
has enough information

to make another API call
to delete itself, right?

Because the object itself
knows how to do that

the library's made an
object that is smart enough

to be able to call delete
on it and it feels like

it's just working that
way, but it's really making

a REST API call to make a delete request.

It's pretty cool right? Here we go.

Message dot delete is not a function.

What I meant was actually remove,

so the function name is
remove on the message.

So here we go.

So, and you saw that
there was an error, right?

That was the error that just happened,

good thing I put that catch in there,

otherwise we would've thought it worked.

So here we go, so in Node explorer,

remove instead deleting,
deleting, deleting.

We deleted all of those.

So remove is the name of
the function that's there,

but it is doing a delete,
making a delete call.

Cool, so we have now
cleaned out and if we try

to run it again, you'll see that there's

no messages left for it to delete.

Awesome, now if you have just watched that

and were very confused,
let's walk this last bit

and then I want you to
rewind it one more time.

So I've made a function
that is asynchronous

and that function is
called delete all messages.

And because it's asynchronous,

I'm able to use this await
which will return this,

this client messages, that
list returns a promise, okay?

But, and a promise of the future.

But because it's being awaited,

it's going to return
it right here in line.

Then I'm gonna loop through
each of those messages

and because that message
came back from the API

and an object was created
thanks to our helper library

here I have a method on
that message called remove.

And it will actually go
and do that next level,

the next level of delete there for me.

So it's really nice.

This object feels like
it would feel if you were

writing JavaScript code,
it would feel this way.

But behind the scenes
we know that it's doing

this API calls and the client library

has extracted all of that away from us.

And if now if you go and you take a look,

let's go back really
quick, let's take a look.

There's other helper libraries.

So if Python happens to be your language,

there's how you do it.

So it's client messages dot
list and for record and messages

and you print the record SID
and you can see that the code

looks a little bit different
in all of the languages

that you go through, but
it's also kind of similar.

And so that's really nice
about the standardness

of a REST API is that the helper library

is producing code that feels the same

in each way because the
library's kind of the same.

And you'll find that as you use other APIs

and they have helper libraries,

they will mimic the way
that the REST API looks.

So I realize that was a lot.

I don't want you to get
hung up if you feel like

you can't completely
understand what that is.

In the next unit what we're
gonna do is we're gonna go

into more deep things and
I know you can do this.

So, this code is there
and also if you feel like

you want me to go back and
explain that again, please,

please, please, please
pause me, slow me down,

let me walk through those different things

but don't feel like you need
to be able to read this.

I want you to just conceptually
understand that you're using

a helper library that's
abstracting away all

of the HTTP API things that we were doing

with curl and we are doing with REST Fox.

This is just doing it in code
and it's doing it for you.

A lot of the magic is gone and
hidden and tucked away and it

just feels like you're actually
working with these objects.

That's the power of the
abstraction. Awesome.

Did you see how the helper
libraries are all similar yet

match the development workflow
and style of each language?

This is one of the benefits of
helper libraries in general.

They abstract away the
HTTP client connection

and the boiler plate necessary
to make REST API calls.

They also behave as you
expect them to behave.

It feels natural.

The way that we were able to
delete from the resource itself

helps to unlock another
REST API constraint

scavenger hunt item and
that one is uniform design.

Now this constraint has four subsections,

one of which we just discussed,
resource manipulation

through representations,
because enough information

was included in the response, it was clear

for us how we could modify
and delete the resource.

Another subsection and here is

resource identification and requests.

That's the URIs that are
included and we've seen that.

But because the URIs are included we know

how to get and manipulate
specific resources.

Uniform use of the http
verbs is pretty powerful.

We just wrote some scripts

that make use of helper libraries.

These libraries are super handy for

automation based tasks or batch scripting,

which is like making a whole
bunch of calls at once.

Now while we're talking
about this, we should cover

another common tool for
talking to external APIs

and that one is CLI,
command line interface.

There it is again.

Command line interfaces
can be used to make

API calls from an
executable on your machine.

More and more these are showing
up for tools that require

authentication and do a
bunch of different services.

This concept is popular
amongst cloud providers

where setting something up needs to

be done quickly from the command line.

Check the notes for more.

Another commonplace where
you'll use helper libraries

is from within applications
that you're building.

Let's get to the final unit
of this course and implement

an external API into an
existing web application.

You've got this. Ooh, we're here.

I love this part. The building part.

We are going to build a web
application that shows off

a set of user submitted
photos for a specific prompt.

But here's where our app is gonna

stick out from all the rest.

We are gonna let our
users submit their photos

and captions via a text message.

What this will enable
us to do is put up signs

and billboards and
physical spaces that says

text a photo to this
number and then our site

will gather those on a
webpage and display them.

Now you're probably wondering
two things right now.

The first one is probably, wait,

what are those photos
they're gonna be texting?

And that's a great question.

We are gonna be building

this application so it can be dynamic.

So you can define whatever you want.

Like text me a photo of your dog,

send us a photo of the
view out your window.

Snap me a pic of the
best impersonation of me.

I don't know, anything along those lines.

Now secondly, you're probably
wondering, wait a second,

you said I didn't need
to know how to code.

If you already know how to make a website,

this part might not have phased you.

But if building a website is outside

of your learning journey
thus far, no sweat,

I've got it set up and
we're gonna take our time

and we're gonna focus on making
things work using this API.

All right, let's do this.

Okay, so I have a template
here in the notes.

In the unit three video one
we have this index.html,

which is our web application.

If you come in here you can scroll,

you can kind of see things here.

The app is called Pickle where
you get to pick your pics,

Peter picked a pickled pickle,
that sort of fun joke there.

And then we're gonna click
this Raw button right here.

We're gonna get a hold of this raw

and I am going to highlight everything

and use the magical
developer Command C copy.

And then I'm gonna come over to back

to my scratch on my visual studio code.

I'm gonna make a new file.

I'm gonna call that index.html,

hypertext markup language, right?

And I'm gonna paste that right here.

So now I have that code
locally on my machine.

If you are a get user, you
could definitely check this out

and have your own version
of this if you wanted to

but that's a good way to
get this here locally 'cause

we're just gonna explore around
here just for a little bit.

Let's take a look at
this file as it exists.

This is something that might happen to you

as a developer who knows now about APIs.

They might say, "Hey,
I've got this template

and I would love for you to be able

to set it up to make the API work."

So the first thing to do, if
you wanna look at an index file

locally on your computer, you
could set up a web server.

I've made it so we don't
need to have a web server

so we can just go ahead,
I'm gonna go to my terminal,

I'm gonna do a new terminal here.

I'm gonna open that up and I'm
just say open index dot html.

Now what that's going to do

in my Mac is going to
open this up for Windows,

take a look and see
how to do this exactly.

But this what this will do,
it will update my pickle here.

So, you can see this is user scratch

and then you know my, whatever it is,

it's in my directory there
and this is what's happening.

There's some nice kitty photos there.

I'll show you how that's
working and if you click

into one of them, you get
a nice little gallery here

and you can switch between
the different kitties

and you can see the text
that the user submitted.

That's kind of where
we're going with this.

That's what we're planning
on doing. Very nice setup.

Simple one little pager
application because I'm using

some APIs to be able to
do that here locally.

I'm using, remember APIs, not Web APIs,

but I'm using a View as the
framework that I'm using.

I'm using a framework called View

and it has an API and I'm also using this

Silent Box which is allowing
us to do that popup.

It also has an API.

Let's take a little bit of a look here.

So I'm gonna move a little
bit slow through this just so

in case it was your first time
seeing something like this.

I've got some setup here in this head tag.

You can see this html,
this is the head tag.

There's some setup.

So I'm using View and
I'm also using Silent Box

and I've got some very minimal styling.

It's not my forte.

And oftentimes you're
given a template like this.

So you're given, hey,
here's a working thing.

I would love for you to
get some APIs in there.

So the body of the app has this.

You'll see notice this little mustache,

mustache and it says call to action.

So in view this is part
of their API is if you

use this for a template,
it will be replaced

with something from the View Objects data.

So you can see here,
there's this call to action

and that's what this is and
this is why I can change this

and make this say whatever I
wanted to say it would be here.

So whatever we decide to do with our apps,

whatever kind of pics that
we're trying to collect,

that would be where we would change that.

And then you also see here,

there's this silent box
and it's doing a gallery.

And the way that that works is
we pass in this gallery from,

again, from this View Objects gallery.

You don't necessarily need
to worry too much about this,

but I wanted to show you that there is,

this is how View works,
it's a front end framework

and it provides an API where
if I give it a function

called data in whatever's in
here will get returned to it.

And then there's some more,

I can define some methods
on the view object.

One of those methods that I've defined

is called load images.

Part of the API that
View creates is there is

a lifecycle method called
mounted, which means

that when the application
is ready and it has

been mounted onto your HTML
through the JavaScript,

it will call this function.

So it's gonna call this
load images function.

In this load images
function, you'll notice it's

an async image and I've
got some to-dos in here.

This is someplace where you might

be communicating back
and forth with people

as you're working together on a project.

So use the messaging API to
use submitted photos and also

create a web-based API that
matches this expected response.

So that's what we're gonna do over

the next couple of videos here.

So what we see in the start
here is there's this gallery

and it is an array and it's
got some stuff from this.

There's a website called
Place Kitten that I used here.

So you can get different
versions of kitties here.

And there's a description
and there's an alt tag,

which is important because
for accessibility reasons,

this is what it will say on the picture.

So that is what is happening
to be able to make that work.

So we now have our app here locally

and we can change things.

So one of the things, one of
the photos that I want to do,

I love to get photos of
burritos from around town.

So I'm gonna change this.

I'm gonna say submit me a photo

of your burritos and I'm
gonna save that file.

So see it's not saved, I'm gonna save it.

When I go back to my file there,

when I refresh it, you can
see that it says "Burritos."

What are you going to want to gather?

Why don't you go ahead and change that,

change that to whatever
it is that you're wanting

to gather as we build
those projects through.

And of course you know you see

that you can change that however.

So make sure that it's
downloaded and make sure

that you can change that,
that you can change this file

and it opens locally on your machine.

Cool, and so now we have

a little smattering of APIs here already.

So we have a web, we
have HTML working here.

We have this view and this view API has

a very specific API that's
doing this mounted here.

But remember it is actually
an API and we're going

to use a web-based API to be
able to get this information

and we're gonna do that
here in just a bit.

Now that we got our file all
working, let's deploy it.

And by that I mean let's get it up on

the public internet so
everyone can see it.

That is of course after
you take a quick break.

(upbeat music)

We are gonna get our webpage up

on the internet so others can see it.

And this has gotten much
easier as time has progressed.

You used to have to set up a server,

like a physical computer,
buy a domain name

and configure it to point to your machine.

You had to figure out
where to host, like where

to locate your server so
that it was always on.

And arguably the hardest part
after it was live, you used

to have to watch over it in
case too many people came to it.

You didn't want it to get overloaded,

you wanted it to scale up and
be able to handle the traffic.

Those servers are still
around but these days

you don't really need to
worry about them too much.

Now I'm sure that you've heard

the term the cloud and the colloquium.

The cloud is just other
people's computers.

Well let's talk a bit about serverless.

Serverless is just other people's servers.

It removes all those
previous things that we had

to worry about and it
offloads your concerns.

I can tell by the look on your face

that it's probably better
if I just show you,

let's get this application hosted.

So we're gonna have Twilio
host our code for us

and that is to say we are
going to have Twilio be

our web server that will
be used to serve our HTML.

Our project will be serverless.

Now the way you do that is
by using Twilio's serverless

environment, which is here
under functions and assets.

Now if you don't have
that here, if you click

Explore Products and you
come to Developer Tools

and you come over to Functions and Assets,

you can click this little pin icon

and that will make it show up here.

So I am going to create a new service.

So I'm gonna go Functions
and Assets, Services,

and I'm gonna say Create Service.

It could be whatever you want.

I'm gonna call it pickle,

like pick your pics with Pickle Peter.

Services allow us to group our functions

and assets together for our application.

So I'm gonna click Next
and what's gonna happen

is we're gonna open up to a very nice IDE

that'll allow us to edit our code.

Now a friendly reminder, if
you're having a hard time

following along because
my screen looks different

than yours, you are using a
new and improved experience.

So check the notes for
what might be different.

Now traditionally these services here

are used to power Twilio
based applications.

Remember how I said you could respond

programmatically to an incoming message?

Well, functions are a
great way to do just that.

In fact, our current number
has a default response

and we might as well fix it
while we're here, but before

we do that, let's get our
HTML code up and running.

So what I'm going to do
is I'm gonna grab code

from my local machine and if you want to,

you can just grab it from GitHub,

check the notes for more on that.

But I'm gonna go add, I'm gonna choose

Upload File, I'm gonna find my file,

my index html and I'm gonna choose Open.

Now what we're uploading,

we'd like the world to be able to see it.

So, I'm gonna choose Public

and then I'm gonna choose Upload.

So now this files over here,

you'll notice this little green dot.

And this means that it is not yet deployed

and that is, it's not yet available

on the internet in this current state.

So let's do that.

I'm gonna do that by clicking

this Deploy All button down here.

And now we see that
it's green and I'm gonna

go ahead and choose copy URL and I'm gonna

open up a new tab with that there.

And we will see that our site is live,

except it says burritos
and these are kittens,

but we're getting there.

So it's working, it's
up, it's on the internet.

I could share this with people.

The pickle site is up and
running on Twilio's servers.

One of the things that I used

to have to worry about was scale.

Like what if I got a
whole bunch of requests

to this site, would it fall over?

What the serverless solution
is doing is allowing me

to not need to worry
about any of that anymore.

Twilio is handling all those
concerns for me, which is great

'cause now I can focus
on what I was building.

Which by the way, we need to handle

that reply programmatically, right?

So the way that Twilio does
things is with web hooks.

Now if you haven't
encountered web hooks before,

I have an entire course on them
that I link to in the notes.

Web hooks are sometimes
called a reverse API.

That is, instead of you calling
the API, the API calls you.

So let's configure our number

to make use of the right web hook.

So I'm gonna go back
to my number over here.

If I look under phone
numbers and I do manage,

I'm gonna hold down command or control

and click Active Numbers,
I'll open up a new tab.

Nice little hack to keep
your screen open here.

So I've got my numbers
here and if I come in here

to configure it, what happens
is I'm gonna scroll down.

So here's the voice
section and then here's

the messaging section and
it says, when a message

comes in to this web hook and it sends to

this URL here, it does
a post to this URL here.

So the way that Twilio makes use

of web hooks can be thought of like this.

You know when I hit this URL, right?

This URL in my browser,
my browser doesn't care

about what's happening at that endpoint.

It could have been
anything, any web server

like Express, Jingo, a Java
server, it doesn't matter.

What matters is that
what was returned from

my server was HTML or
hypertext market language.

My server responses with HTML

and my browser renders the page.

Now the same is true with Twilio.

Someone is going to text our Twilio number

and Twilio is going to send
a request to an endpoint.

In this case, this endpoint
here, it doesn't matter what

is happening on the other side
as long as it returns TwiML,

or Twilio markup language,
they look very similar.

HTML and TwiML.

Twilio will be able to
render your application.

So we could set up a new web
server to host this application

that returns TwiML or we could
just use a Twilio function.

And like I said earlier,

that is what these are commonly used for.

So let's pop back to our service.

So I'm gonna come here, I'm
gonna add a new function

and I'm gonna name this
function Incoming Message

'cause that's what we're gonna do.

We're gonna handle an incoming message

and there is some very
nice default boiler plate

that is commented that comes through.

So boiler plate is code that's provided.

That's usually the most
common thing that you're going

to be doing and in this case
it is, it's boiler plate

for how to respond to
an incoming phone call.

It's kind of like the hello
world of voice applications,

but we are gonna be building
a messaging application.

So we'll need to tweak this just a bit.

Now I've put this code,

I'm about to show you into the notes.

So I don't want you to
feel like you have to type

this all out or even fully
understand every line.

I'll step you through it, first though,

let me walk you through
this function just a bit.

So Twilio functions all export
a thing called a handler.

And that handler takes
a function that takes

some parameters, context,
events, and callback.

Context here is an object
that holds information about

the function that's running,
like it knows the domain,

it knows the name of the
function and the event here,

you can kind of think of
this like a web request in

most frameworks and if you
haven't seen a framework before,

this is kind of the way that information

is passed into your web application.

So, this is the event will hold everything

about the text message that was incoming

because that's what Twilio does.

Twilio's going to pass that
information through here.

And for instance, that message will

have the to, it'll have from and body.

And again, because when
the text message comes in,

we are going to point our
phone number to this function.

So Twilio will post the information here,

it will call our function
instead of us writing code

that checks if a new message
was added over and over again.

Twilio is gonna call us.

The API is going to
call us via a web hook.

Web hooks are pretty
cool. Check the notes.

And then finally, there's
this callback object here,

which is how we send
information out of the function.

It's actually a function,
so we have this callback,

this is the errors that
might have happened,

and then this is what gets returned.

And here's that TwiML,
Twilio markup language.

So I'm gonna get rid of a
couple of these lines here.

These are sort of demo lines, I'm gonna

get rid of that and I want you to be able

to see what's coming into the message.

So I'm gonna start up here.
I'm gonna do a console dot log.

And what what this does
is when the function runs,

if we want to, we can see the message,

it will show up down here.

So let's say that we
got an incoming message

and it was incoming
message and we'll just do

a colon and then I'm
gonna use this dollar,

this style of string interpolation.

So I have the event object, and on it

there is a property called
body with a capital B.

So that's being passed in there.

So when the function runs, we will see

that the message came in 'cause Twilio's

gonna pass that message
and we'll see it there.

And we're just gonna say thanks
when somebody sends this in.

So we don't really need to do
anything with this message,

but you might wanna
filter it or handle things

differently based on what they said in

the message and you totally could do that.

But you probably also wanna
check the photo that came in

was actually a burrito or
something, not inaprops.

You could do that and
there are APIs for that,

but that's a little out of scope.

So instead of a voice response,

we're actually going to
return a messaging response.

And there's a little
helper library here, right?

So a little helper library for TwiML

and it has this TwiML object.

And before it was doing say,
which is text to speech.

So if you wired this up,

it would say hello world
in like a computery,

but actually pretty good
sounding voice these days.

But I'm gonna change this to be a message

'cause that's what we wanna return.

We wanna return a
message and we wanna say,

thanks for your submission, right?

We wanna thank them there.

And we can also send
any sort of emoji here.

Let's see if maybe a camera
that sounds, yeah, it's nice.

Thanks for your submission.

And so what's happening
here is this object,

it's a fluid API.

It means that it doesn't return anything.

You kind of tweak it and it
builds as things go on it.

So you'll notice that this
isn't returning anything.

I'm modifying this object
and then when I send it

out at the end, that's how it goes out.

So let me, let's just,

let me show you what
that object looks like.

So again, I'll do one of these console log

and use the back tick and we'll say TwiML.

So Twilio markup language was TwiML.

And you'll see that it
looks a lot like html.

There are some rules to it,

but we don't need to
learn them all right now.

So I'm gonna save this
and just like before,

you'll notice that this is
gray, it hasn't been deployed.

So I'm gonna click Deploy All and while

that's building, I'm gonna head back to

my phone number page and
I'm gonna refresh it.

So on my phone number
page, I need to change

my message down here it says,
when a message comes in,

we want it to be a function
that is in the pickle service.

That's done in the UI.

And we want to choose incoming message,

which it hasn't finished deploying yet.

Just finish deploying, one more time.

Let me refresh that page.
So that shows up for us.

We're going to go to,
when a message comes in,

it's going to be a function
and it's on the pickle service

for this UI and we wanna
do incoming message.

And if we do save, alright,
so we should be all wired up.

I'm gonna click Clear Logs here,

and I'm gonna turn live logs on.

You can see that this says
live logs on when it's ready.

And I'm gonna clear
the logs one more time.

And what I'm gonna do now is
I'm going to send a message in

and we should see this, we should see

what I send in and we should see the TwiML

that was sent back and I
should get a response back.

So let me send that message
here. Let me send this text.

All right. So, oh, check out this.

I have this beautiful
picture of a burrito.

I love when burritos can
stand up by themselves.

And this is an awesome one.
I'm gonna send this in.

So check out this beautiful
burrito, little emoji.

I'm gonna send that through
and we should see here in

the live logs, we should see
the message come through.

There we go, so look at
this beautiful burrito,

and this is the TwiML that was generated.

So you can see it's like tag-based.

So there's a response and
there's a closing response

and there's an opening
message and a closing message.

Thanks for your submission.

I don't want you to feel
like you need to learn TwiML.

You could do that later if
you need to, but this works.

So I got my message back.

Now, remember, since we are in trial mode,

if somebody else sends in a message

to your phone number,
they're only gonna get

a message back if they're
a verified sender.

So that is a limit of the trial API

that we're using currently.

Now most APIs have limits.

There's only so many calls you can make.

There's, you can only
send to verified numbers.

There's just different sort of limits.

And that's what we're
working with here right now.

The limit is that you can
only send to verified numbers.

They can still submit,
they just won't get this

"Thanks for your submission."

So your phone number should,
so when you submit from

your phone number, you should
get it just like I did.

All right, so we're looking good.

We have our site hosted and we are

handling submissions by thanking them.

Let's get to some more cooking.

Now, if you're interested in learning more

about applications like
this over the phone,

check out the notes for more resources.

I have an entire course on this

if this piqued your interest.

But for now, let's get back to our API.

Now, with our ability to
host our own application,

we can focus on designing our own API.

Now the great news is that
Twilio functions makes it

really straightforward
to return JSON, remember,

that's JavaScript object notation,

the lingua franca of the web.

Let's design our web-based API to return

the expected format, and we can
make use of Twilio's message

API to get a hold of all the
messages that we received.

Do you see what I did there? Get, get it?

All right. I'm a get outta here.

I can't stop. All right, let's do this.

Okay, so we are gonna
actually write an API

and we already have a spec
or a specification, right?

We need to provide for
this specific plugin,

This silent box has this gallery plugin

and it has a specific API that it defines

and that API looks like this, right?

So remember that we're
setting this gallery and we're

setting an array and we're
setting this information here.

So I think we should start
by creating an endpoint

that returns exactly what we have here.

We should return an
endpoint that does this,

the returns this, and then
we'll move forward from there.

This is what I do when I find
myself in a situation when

I'm working on a project
with a team of people, I take

what they expect in a template
and I return it from an API.

This way they can keep working
and I can keep working too.

So let's do that. I'm gonna
create a new function.

So I'm gonna choose add, add function,

and I can name this whatever I want.

And I suppose we should be clear, right?

We're gonna make an API,
we're actually gonna

make one so slash API and then I suppose

we should probably say what it's gonna be.

So we'll do a Pics API here, right?

And I'm going to press Enter

and that will get me my boiler plate code,

of which I am going to
get rid of everything.

So thank you for the help.

We're not actually
returning TwiML this time.

We're actually gonna return an object.

And what I'll do is I'll copy the

hard coded array from
this index file here.

I'll come in here and
I'll copy this hard coded.

Now hard coded means it is just like

in the code this way, right?

There's no way that this
is going to be dynamic.

I'm gonna change that here.
I'm gonna paste that in here.

I'm gonna name it the same thing.

So I'm gonna create a new
variable called gallery

and I am going to just paste
that hard coded code there.

There we go. And then I'm
gonna call this gallery.

So again, I have an array.

That's what this bracket here is an array

of these objects, that's
what these objects are.

These mustaches, they
open up and the objects

have these properties here and these are

representing the pics
that that plugin requires.

And now I'm gonna use
this callback function

to return that gallery array.

One really nice thing
about this Twilio function

is that if I pass it an object like I did,

it'll automatically return JSON to anybody

who requests the URL, so let's do that.

So I'm gonna go ahead,

I'm gonna save this and
I'm gonna deploy it.

Now one thing to note, by default
it was actually protected.

That's what this little
key lock thing means here.

So I'm gonna click this
and I'm gonna change this

to be public 'cause we
actually want anybody

to be able to see it, not just Twilio.

So this is what we're gonna do.

I'm gonna change this to be
public and then I'm going

to choose a deploy all and
you'll see that it's gray

and when it's ready it
will turn green for us.

And so I'm gonna go ahead
and I'm gonna copy this URL.

So I have this URL already
and when it's green,

when this goes to be deployed,
so it's still deploying,

you can see it's deploying
and you'll know down here

when it'll say build completed
and it'll say deployed.

So it's deployed, so I
copied that URL, I am gonna

go hit that URL and let's
see what we get back.

Awesome, we got it.

So we got the kitty descriptions

and blow this up a little bit here.

This is JSON, it automatically
built this for us, right?

It's in the right format,
which is very nice.

In fact, we could probably
take this and why don't we,

we'll go over to the Thunder Client

and take a look at what's
going on over there.

So I'm gonna come back
to my Thunder Client,

I'm gonna make a new request
and I'm gonna hit, I'm gonna

do a get to this API that we
just built and check it out.

It comes back, it comes back with 200 OK.

And here's, the stuff that's coming back.

There's even some headers
in here. Oh, sorry, some.

If we look at the response, we can look at

the response headers
over here and we can see

that the content type was
set to application JSON,

Twilio always sends back to

the shenanigans none, which I love.

So now what we could do
is we can give this URL

to the team that's working
on making the front end,

you know that view application,

they could wire it up,
they could take this.

And as long as we match the
same format in what we return,

that is, as long as our API
maintains the same contract,

everything should just work.

So that's pretty awesome, right?

So let's move on to the next part.

I'm gonna comment out this bit.

So let's go ahead, let's
give it a, we'll we're

gonna go ahead and make
this an empty array, right?

So that's how you make an empty array.

And I'm gonna comment this out so that

we have it so that we can kind of look at

what the format is as we build stuff here.

So I'm gonna comment that out and in fact

I don't think I need the second one.

I'll just get that first one there

and give us some space there, awesome.

So now let's use the text messages

that were sent in, our incoming messages.

So we are gonna write
some JavaScript code.

Now if you aren't quite
fluent yet in JavaScript,

remember that is okay
and we've all been there

and we all, all of us, I guarantee you

everybody watching this understands

that what you're going
through can be challenging.

It's a new language.

I want you to try a
follow along conceptually.

And I want you to take
your time and I want you

to take advantage of being
in a video-based course.

This code that we are going
to write will be available

in the notes and I will walk us through it

and then I'll go over
it again translating it

into the concepts that we've covered.

Okay, are you ready? Let's do this.

So Twilio functions have
another great feature.

I can get access to a REST client,

to the Twilio REST
client then authenticate

a Twilio REST client
from the context object.

So context, get Twilio client.

Now remember that is going
to be using my Auth token

and my account SID, and
it's on this context,

it just automatically is authenticated,

which is really powerful
'cause now I can get access

to my thing because this
function is running as me, right?

So that's why it has
access to that information.

So remember we wanna get a hold of all

of the messages that were sent in.

So we're going to use the API to do that.

And remember we could have
multiple phone numbers.

So I'm gonna get the messages

that were just sent to this phone number.

So I'm going to await

'cause remember it returns a promise.

So client dot messages dot list.

And I need to do the ones that

are specifically to my Twilio number.

So that's (561) 816-5433.

And I'm pretty sure that's right.

I'm gonna look one more
time at my, oh there it is.

Yeah, that's it. So that's
my phone number there.

(561) 816-5433 you could go.

So there, it's also on your console.

Remember down here at the bottom,

(561) 816-5433, that's what I wanted.

I put that there and in fact, you know,

that's something you can
have multiple numbers

and that might be something that you want

to store possibly in an
environment variable.

So I think we should probably
do that. Let's do that.

So I'm gonna take this number here

and I'm gonna store that here.

You can see it in the
functions and the services here

we have this environment
variables, let's add to that.

And you'll see here, actually
add my Twilio credentials.

My account said my Auth token
to M, so that's why context

get Twilio client works is
because we've checked this.

If not, it won't work.

So, but it's checked by default.

So we're gonna do Twilio
number and that value

is going to be that and now in my code,

what's rad is I can use that like so,

I can say context dot Twilio number,

I can access anything that is
in those environment variables

that way and it's now it's in this code.

And now when I share this code,
you won't need to do that.

You will need to set your
environment variable though.

Awesome, so, and now what
we've gotta access to the,

well actually first we
set await and we need

to make sure that this function is marked

a sync so that that's required, right?

In order to make this work.

So now it's going to get the messages,

it's going to return the messages,

and now we're gonna loop
through those messages.

One of my favorite ways of
doing that is this for of loop.

So we're gonna say for
message of messages.

And for each one of those messages,

we're gonna go through some things.

So one thing you might not
have thought about before is

that when you send a message,
you can put multiple photos.

I think typically whenever
I send, when I just send one

or then I send another
message and another message,

you can actually add multiple
pictures before you send it.

So let me, let's do that.

Let's get a hold of all of the
pictures that are available.

So we'll say comp pics, we'll call,

we'll call our variable called
pics, right, for picture,

short for picture and
we'll say, await message.

Now the message object that
came back from this API.

Now we know that this was an
API call, but it is an object.

And that object actually has
access to these sub resources,

which was media, which we
walked through this before,

remember where there was the media URL

and we grabbed that
media URL and we looked

at all of them that were available?

This is basically doing that same thing.

And we're gonna get all of
the media that is available.

All right, so we have
that, we have the message,

we have all of the
pictures of that message.

And so for each of those pictures, right?

So each of the pictures,
we need to actually need

to declare the variable
just to be better there.

So we'll say for const,
pick of pics, right?

So we're gonna make a new variable called

pic looping through each one of these

that came back from this array, right?

So, for all of the messages,
for all of the pictures

in the messages, now what we're gonna do

is we're gonna add that to this gallery.

So this is an empty array,

but we're gonna dynamically add to it.

And the way that you add
to an array of course

is with gallery dot push, we're gonna push

a value onto the end of that array.

And we know what this is
supposed to look like, right?

It looks like this, it looks,
we have this source, right?

So source here, SRC is short

for source just from
forever in the internet.

So image source, SRC and
I know from my notes,

and I'm gonna pop over here real quick.

That this has, the media
resource has this thing called

a URI on it and it's relative
to this https.twilio.com.

So let's paste that.

So it's relative to that,

which means I that if
I'm going to display it,

I need to let our people know I'm gonna

give it a full URL,
which it requires, right?

It requires this full URL.

So it's got the front part of it.

And then I'm going to use the pic as

a property called URI, which we saw.

And remember what happens
is it has this content type

if we want to without an
extension, the media is returned.

Now I know that by default this is going

to give me this pic.URI is
going to end in dot JSON.

So I wanna replace that, I'm gonna use

the string method to
replace the dot JSON, right?

I don't want that dot JSON,

I want it to be no extension at all.

So I'm gonna use this empty string.

So I'm gonna replace the end of

what this pick was with dot JSON.

I'm gonna replace that
with an empty string,

which will remove it essentially, right?

That's what we're gonna to do.

Now I'm gonna do a comma
'cause I want to do more,

I want to have the description.

We wanna put the description
here as required because

that's what the little text
is at the bottom that it says,

and that's whatever they texted
in, in their message, right?

So I'm in this loop, I'm
looping through each one

of the pics, but I'm also, I
have access to this message

'cause I'm in this inner loop here, right?

So I still have access to the outer loop,

which is message dot body, right?

So those are inflated.

So that's whatever the text
was that somebody sent it in.

And we should also, we'll
make that the alt text too.

So alt tags are handy for
accessibility reasons.

There are people, you
might not think about this,

but there are people who are
going to use your application

that are using it without
being able to see,

some people are vision
impaired and they have

screen readers and alt
tags are awesome for that.

You always wanna make sure
that you make things accessible

for people who can't see what
it is that you're providing.

And alt tags are an
excellent way of doing that.

This is just one way that
you can make your application

more accessible and everybody
wins by it and then finally,

I'm just gonna grab this

last thumbnail width here, 200 pixels.

We can see later if people want

something different than that, what to do.

So, our gallery array for
each one of those pictures,

it's gonna add to it, right?

So it's gonna go and
it's gonna add each one

of those and we're still
gonna return that gallery.

And I think y'all, I think we got it.

Let's walk it one more time. Okay.

So we're gonna come in
here and we are going

to use the context that was passed in

to this function when it was called.

So when somebody hits
this URL, this function

is gonna run and it's
gonna know it's gonna

have access to those environment
variables that we saw.

It's gonna get access to
an authenticated client

and that client is logged in with

my account SID and my Auth token.

And we're gonna create an empty array,

this gallery thing here, we're
gonna create an empty array.

It's a list that we're going to populate.

We're gonna take our
messages and we're going

to push them into this
array so that it has

the format that is expected,
which is right here.

We're gonna turn what our
messages look like into this

so that later if we can use them that way.

So the way that we do that
is we use this client,

this client is a REST
client and it's gonna hit

the messages endpoint and
we know that it's going

to do a get, but it's
been abstracted for us.

So just, we're just say,
hey, list all of the numbers

that were sent to this
Twilio number and those are,

this context here, again,
this is passed in and the

Twilio number is set in my
environment variables over here.

So we're set 'cause because
you could have multiple, right?

You could have multiple
Twilio phone numbers.

So we wanna say only the
ones that were sent to.

So we're very, we're being very specific.

We're querying messages that
were sent to this number,

not from this number but to this number.

And we're gonna loop through
each one of those messages.

And for each one of those messages,

the object that's returned
from this has this property

called media, which lets
us get to a sub resource.

And you'll remember in the
JSON, there's a link to this

and we could go and query
this ourselves, but we don't

need to because the API
has wrapped up for us.

It's very nice, it's
nice, nice abstraction.

And we're going to get
the list of those picks.

And again, this is asynchronous.

We're using this, we're
waiting for it to come back,

we're waiting for these
values to come back.

So once we have these picks, we're gonna

loop through each of the
pick and we are going

to push out a source that has this.

We know that they all need
to start with API twilio.com

because the URI itself, this
URI here is relative meaning

it doesn't contain the
forward slash of this.

So we are going say
this is where it lives.

This is the API call that we
want you to do to get this

content is API twilio.com,
whatever is in the pick URI

'cause that's unique to
each one of the pictures.

And that URI comes with
a JSON at the end of it.

So if you look here,
let's see if we look here,

we can see that it ends
in this dot JSON, right?

And we want to get rid of that
'cause when you do get rid

of it, what happens is it
returns the actual picture.

We did that, I don't know

if you remember that earlier, we did that.

So, that will be removed
and then we're gonna use

the message and the message
is coming from here, right?

So the message for each of
these messages, we're gonna

get the message.body and the
description and the alt tag

for it, the alternate
text we're going to set.

And that's from that,
this is the required for,

remember this looks exactly
like what happened here.

So we are returning that here
and it should return JSON.

I'm going to save it. We
are going to deploy it.

We are going to cross
our fingers because this,

we are at that point where
we hope that the code

that we wrote works and
if it didn't, it is okay,

if it didn't work, we are
gonna work through it.

We might get an error, we
might not understand exactly

what that error is and we
are gonna work through it.

But I am going to save this and deploy it.

Now, let's assume that I gave
this out, I gave this out.

So now if somebody hits
this API, here we go.

So that's what it was before.

If we hit it, we should
see burritos. We got it.

So it says, "Look at
this beautiful burrito."

I texted that in. Wow.

Look at the clarity of the burrito.

Oh my gosh, you can see the
rice in the burrito emoji.

That's impressive. I didn't know that.

Look at that cat. All right.

So in fact let's go,
let's go hit it with our,

let's hit that same
request I wrote before.

It should be a little bit different now.

It's coming across here and I want

to look at the response and the response.

I'm gonna go and I'm gonna grab this URL

and make sure that it works.

So the source, right, the source that

came back here is, should
be the picture of it.

And if we look at it should
see my beautiful burrito.

Oh look at this thing,
I believe that burritos,

when they can stand up by themselves,

that's the sign of a good burrito.

Look at that burrito.
I got that in Arizona.

Oh man, and what we did with this code is

actually pretty common,
now in an app like the one

that we're building,
probably eventually what

you're going to do is you're
gonna store those photos

that were submitted
into a database, right?

And you're gonna do that from

this incoming message function.

You're gonna get it, you're gonna store it

if it's valid, if it's a valid picture,

you don't wanna show pictures that aren't,

you're gonna store it
in a database and then

you're going to format it
for whatever your client is.

You're gonna get that from a database.

So maybe instead of
coming back from this API,

you're gonna come from a database API

and you're gonna pull
back your information

and then you're gonna push it through.

And that database is gonna
be in its own format,

but you're going to make
it match whatever it is

that you are trying to push out there.

You're not gonna, it's not gonna

look exactly like the message, right?

I'm not gonna send back
one of these messages

and make my API look like that.

I'm gonna shape the data.
That's what that's called.

I'm gonna shape my data in the
way that I want to be used.

And we came with the spec.
This is the shape of the data.

So we took the data and we shaped it,

we formed it into what was expected.

All these burritos are making me hungry.

I think I'm gonna go fetch
one from my favorite taco-ria.

Now I'll make sure to snap a pic.

You should get one too
actually. You deserve it.

You deserve a burrito
and when we get back,

we'll look at how to fetch this data

that we just generated in our client app.

So we've coded our external public API

and it's ready to be consumed.

Now our API uses an external API, Twilio,

and we're going to need to use our

web framework Views API
to retrieve the data.

And to do that we're gonna
need to use the web API Fetch.

See, APIs are everywhere.

No wonder you came
looking for this course.

All right, let's make use of our

server-based API and our
client side application.

All right, so just like I
just consumed my burrito,

we are going to consume that
API that we just created.

So if I scroll down here,
remember we're passing

in this gallery here
and we scroll down here

into this load images and this load images

gets kicked off from
the API of view, right?

So view has these lifecycle APIs and when

the things mounted, it's
gonna call this load images.

We're gonna come into load
images and now we have some

to-dos that we have already to done.

So we are going to use the

messaging API to use submitted photos.

We did that, we did that in our API

and then we are going to
create a web-based API

that matches this expected response.

We also did that, didn't we?

We did that. So let's get rid of that.

All right, so here we go.

So this has got a suggestion here

of what to start doing here.

So I'm gonna uncommon this.

So we're gonna create a new
response object and we are going

to await and we are going
to use Fetch and Fetch here

is part of the web API that
browsers must implement

to do exactly what we're
trying to do, right?

We want to fetch data from our API.

Now this happens to be on the same server.

So we can use a relative link
like this slash API here.

We don't need to specify
the server, right?

It's assumed. So our API,
we called that, right?

We called it API/pics.

So slash pics is what we
are going to hit there.

And you notice that it's using await

because this is an async function.

So Fetch returns a promise
and it's going to return

that response and that
response has a method on it

called JSON that will actually return

the JSON representation
of whatever came back.

So what I'm gonna do is I'm gonna get rid

of this gallery, this hard coded gallery

that is gone and I am
going to say REST await.

We are going to await 'cause this method

is also asynchronous, response dot JSON.

So that's gonna get back whatever is

in this response that came back.

This response has all
sorts of metadata about it,

but we just want to
get the data out of it.

And that's by using this dot JSON.

And because our API is JSON enabled,

it's just gonna come out.

All right, let's deploy it. I cannot stop.

Oops, this is not unable to
deploy 'cause I didn't save it.

So I need to save it first.

I cannot stop thinking about
that burrito. It was so good.

I submitted a selfie of
myself and I texted it

to my Twilio number and I got a reply back

from my Twilio trial account, right?

And it says thanks for submitting it.

So if all goes well when we look here,

I'll be able to show you the burrito

that I texted to my number.

So it's been deployed and
I'm gonna come in here

under this assets and
I'm gonna copy this URL

and I am going to paste it
here and this view application

is gonna go and it's gonna
hit my API and it's gonna

bring back some photos into
this gallery and here it is.

Look at the size of this thing.

It was truly bigger than my head.

So if we click that, we could go,

we could see my other beautiful
burrito there as well.

Now let's look again back here
at the client side of things

and just take a look at
how beautiful this is.

It's just two lines and
it's hitting our APIs

and that's the power of this API.

We were able to hit an
API and get user submitted

text messages, text photos, right?

And it only took two lines and really

it only took one line actually.

You know, like if we could have

like chained some stuff on top of this.

Awesome, now one thing that
I do wanna note is that

there's no authentication
at all to this API, right?

I didn't supply any
authentication information at all.

It's open to everyone and
that's kind of a good thing

if you are working on a
client side application,

you don't wanna pass your keys around.

Like I would not wanna
put my Twilio keys here

on this page because I
don't know if you know this,

but you can actually see
everything that comes down.

So I'm gonna view the source
of this and you can see here's

the source that we're looking
at and if I hadn't used

any sort of API keys, I
would see them right here.

You don't wanna leak your
keys that way, check the notes

for more information on
how to get around this.

But typically this is
what you do is you write

a server that then the server keeps track

of all the keys and you
connect to the server.

But if you do need to
provide some authentication

locally on the client,
there are ways to do that.

Check the notes. But look
at this, look at this.

You did this, you have
designed a new interface,

a text messaging interface, right, a TMI.

Well I hope this wasn't TMI

or also known as too
much information for you.

You learned a whole lot about APIs

and not just the web-based ones.

You saw them in practice and
you even built your own one.

You really deserved that
burrito. Awesome job.

You've just built and
consumed your own API.

Now here's my question to you.

Do you think that the API code that

we wrote together should
be considered RESTful?

Well, why don't we take a look at

our weathered scavenger hunt card.

So it's definitely a
client server architecture.

Our client happens to be, in this case,

a view application running in the browser

and our server is a
serverless node application.

But any client could connect and use this.

Statelessness. It's
definitely stateless, right?

We aren't requiring any prior knowledge

about the client, cacheability.

Well, at the moment we
aren't providing any

caching information,
though we could, right?

We could fairly easily pay
attention to those headers

coming in and we could
respond appropriately.

It would require us writing
some additional code

and thinking through
some of the edge cases,

but we could do it.

Let's put that in the maybe column.

Layered system. Yeah, for sure, right?

In fact, it's a little layered already.

Our API is calling another
API, but our client

doesn't need to know that,
we can also add additional

functionality and the
contract wouldn't change.

Code on demand. We haven't
even talked about this one yet.

And it's the only optional requirement.

Basically this means that
your API returns code

that is runnable, like maybe it returns

an embedable widget or some
actual JavaScript code.

This doesn't make any
sense in our use case

and that's totally okay.

So we're gonna drop this
one into the no column.

So we're looking good so far.

But here comes the
doozy, uniform interface.

So remember this one has four subsections,

resource identification
and requests, ruh row.

Currently we are just
representing all the messages

as objects and absolutely
no way to identify them.

So we failed this sub requirement

and therefore this is a no.

But let's keep going
through the rest of these,

pun intended, sorry.

Resource manipulation
through representations.

We definitely do not allow any sort

of manipulation of the images
so this is another fail.

Self descriptive messages, we
haven't gone over this yet,

but by using headers we
can tell that this is JSON.

The message sent down
has a type and it's clear

that it should be JSON decoded to be used.

Hypermedia as the engine
of application state.

And last but certainly not
least, HATEOAS or HATEOAS,

it's an often forgot about
part of the RESTful constraint.

And the idea here is that
there are links to show off

what more you could do with
this and where you could

find related resources,
it provides URIs or links.

And we did see this in both
the Spotify and Twilio ones.

However, ours doesn't provide
links to other resources.

So we don't have a RESTful
API and that's okay,

it's gonna suit our needs.

It does look like we could get

there pretty quickly if we wanted to.

One thing I want you to gain
from that exercise though is

that you now have the ability
to identify whether or not

an API is RESTful and I
hope that felt pretty good.

We've now completed the scavenger hunt,

we revealed all the constraints,

and I hope most of those are pretty clear.

Please don't feel like you
need to memorize those.

You can find those same constraints

littered all over the internet.

Now as a prize for finishing

the constraint scavenger hunt,

I've dropped links to my
favorite REST API constraint

documentation for you to
lean on, should you need to.

I've also included links to
the Popular REST API frameworks

that will help you design RESTful APIs.

Make sure to check out
the notes. You did it.

You just completed a
whirlwind introduction to APIs

and I hope that you can
see how much more power

they can add to your programming journey.

By looking at interfaces in general,

I hope you're more comfortable
with the idea of not

fully understanding exactly
how something is working,

but still leaning on that abstraction

to build your tools and applications.

Do this all the time with
physical object interfaces

and APIs or application
programming interfaces.

They aren't all that different.

I hope you enjoyed taking this course.

I know I had a lot of fun making it.

If you think someone
you know might benefit

from this course, please
share it with them.

I'd love to hear your feelings,
your thoughts, your dreams.

So I threw together a
little something using

a smattering of APIs to
capture your feedback.

If you've got the time, I'd love to

have you answer a quick text-based survey,

text "feedback" to the
number on your screen.

Well actually, you know what, if you want,

you can also call and just
leave me a message too.

I use an API for that too.

So please, please, please
keep me posted on your journey

and really, I can't wait
to see what you build.

Thanks again for hanging out
and we'll see you real soon.

(upbeat music)