►
From YouTube: AsyncAPI and WebSocket
Description
Stream covers an intro to WebSocket API and to use it with AsyncAPI specification.
Blog post about the subject:
- https://www.asyncapi.com/blog/websocket-part1
- https://www.asyncapi.com/blog/websocket-part2
Timeline:
0:00 Lukasz talks on mute. Why not :)
5:03 Intro
14:41 What is WebSocket. Some history and use cases
26:40 Why AsyncAPI. Why WebSocket needs it
29:33 Let's start with WebSocket API in Cryptocurrency trading.
31:10 Playing with Kraken API
41:08 Start writing AsyncAPI document for Kraken WebSocket API. Single-channel with multiple messages
1:19:39 Start writing AsyncAPI document for Gemini API. Channel with parameters and bindings and a single message
1:40:27 Ending
A
A
A
So
the
the
goal
here
is
to
actually
repeat
what
I
saw
what
I
already
wrote
in
two
blog
posts.
Why
repeat?
Because
I
noticed,
even
after
my
looking
at
my
own
experience,
many
people
don't
have
time
to
read.
I
don't
have
time
to
read.
I
have
many
blog
posts
open
in
tabs
in
the
browser
that
I've
never
had
time
to
read.
A
Unfortunately,
but
it's
affecting
the
learning
capabilities,
so
the
the
plan
here
is
that
I
want
to
as
as
often
as
possible,
to
provide
a
a
podcast,
a
recording
or
just
a
youtube
video
that
explains
some
subject
that
I
described
in
the
in
the
blog
post.
So
you
don't
have
to
spend
like
20
30
minutes
on
on,
like
just
focusing
on
the
on
the
content
of
the
blog
post,
but
instead
you
can
actually
prepare
a
dinner
in
the
kitchen
and
at
the
same
time
listen
to
the
to
the
recording.
A
A
Slack,
I
turned
off
slack,
so
there
are
no
notifications
showing
up
and
I'm
not
being
disturbed,
but
if
there's
something
important
like,
for
example,
I
see
that
once
on
our
asking
dps,
like
many
people,
also
asked
me
like.
Let
me
know
that
the
recording
is
off
the
voice.
Recording
is
off
so
that's,
I
think,
a
good
reason
to
have
the
yeah
slack
opened.
A
A
A
A
A
A
A
A
So
I'm
I'm
gonna
basically
combine
those
two
and
add
something
extra.
What
I've
learned,
even
after
publishing
the
blog
post,
there's
also
a
third
blog
post,
so
feel
free
to
share
your
opinions.
If
you
want,
I'm
gonna
paste
the
link
as
well,
so
a
third
blog
post,
which
is
the
last
blog
post
about
websocket.
A
A
I
think
it's
a
first
time.
It's
gonna,
be
it's
gonna
happen.
It's
gonna
happen
soon,
19th
of
may
so
it's
almost
no
yeah
less
than
less
than
two
weeks
and
the
agenda
is
not
yet
available,
but
yeah.
I'm
gonna
make
a
session
about
asking
api
and
websocket,
but
from
the
point
of
view
of
like
async
api
as
a
tool
that
you
can
use
to
design
your
api
first
and
then
generate
code
and
then
continue
working
with
your
with
your
features
and
solution.
A
But,
as
I
said,
that's
already
recorded
it's
going
to
be
released
on
the
on
the
day
of
the
of
the
conference.
That's
why
I
didn't
plan
any
live
streaming
about
it,
but
if
you,
if,
after
watching
the
recording
from
the
conference,
you
think
it's
it's
something
needed,
then
yeah
feel
free
feel
free
to.
Let
me
know
I
can.
I
can
set
up
something.
A
A
A
A
So
it
was
a
mark.
You
could
have
you
had
a
marketplace
of
apis.
You
could
build
front
store
or
any
different
things
just
by
subscribing
to
those
apis
and
using
them,
and
we
were,
of
course
we
always
wanted
to
do
there.
Some
innovation,
innovative
stuff-
and
we
also
wanted
to
have
like
nice
uis,
where,
where
you
can
provide
a
nice
experience
to
the
users,
so
they
don't
have
to
to
see
updates
in
the
ui.
A
One
of
the
the
basic
approach
I
think
people
choose,
and
that
was
the
the
first
thing
we
we
could
think
about
when
we
wanted
to
provide
such
an
experience,
was
that
yeah?
Let's,
let's
do
some
calls
in
the
background,
so
user
doesn't
see
them,
but
then
we're
gonna,
just
ask
the
the
api
from
time
to
time
to
see.
If
there
are
any
updates-
and
that's
that's
actually
something
that
is
called
http
polling,
but
I'm
gonna,
I'm
gonna
explain
it
using
a
shrek
case,
because
I
think
many
people
know
shrek.
A
A
So
there's
a
I'm,
not
sure
if
it's
episode,
two
or
three
there's
a
scene
where,
where
shrek
and
fiona
they
travel
to
far
far
away
and
and
donkey,
it's
he's
pretty
annoying
there
at
the
back
seat
because
he's
just
like
a
kid
right,
so
he
he's
bored
by
the
travel
and
he's
asking
shrek
over
and
over
like.
Are
we
there
yet?
Are
we
there
yet?
Are
we
there
yet.
A
A
Where
you
have
a
client
on
the
server,
so
basically,
whenever
you
want
to
have
updates
from
the
server
you're
you're
opening
a
new
connection
to
the
server,
that's
how
http
works.
So
you
just
open
a
connection.
Ask
for
updates,
get
the
response
and
do
something
in
the
ui
and
you
do
it
over
and
over,
and
there
are
different
ways
of
doing
it.
A
A
It
should
work
in
the
way
that
you
just
connect
to
a
a
given
socket
a
given
channel
and
that
will
always
provide
you
messages.
We
will
send
you
messages
with
the
latest
information
about
the
about
the
status
of
a
travel
too
far,
far
away,
for
example.
So
you,
instead
of
asking
all
the
time
you
just
say,
okay,
send
me
updates
and
then
server
depends
on
the
on
on
the
settings.
A
A
The
view
without
the
browser
refresh,
but
then
when
you
go
to
the
developer's
console
in
the
browser
in
the
network
tab,
you
can
see
like
a
new
request,
http
request
going
out
from
the
client
to
the
server,
not
not
cool
and
and
with
websocket.
That's
not
that's
not
the
case,
and
it
works
pretty
pretty.
A
Okay
back
in
game,
so
there
are
other
solutions
like
between
2011
and
2020
21,
for
example,
http
2
showed
up
and
as
far
as
I
know,
there
are
some
there's,
a
movement
to
maybe
consume
it
and
use
it
for
websocket
and
as
a
replacement
for
websocket
and
there's
also
this
mercure
protocol.
And
I,
if
you
want
to
more,
learn
more
about
mercure.
A
A
So
there
are
many
different
solutions,
but
the
thing
is
that
websocket
is
it's
here
for
very
long
and
there's
there's
a
lot
of
implementations
already
so
like
seven
years
ago,
I
remember
like
we
had
we
had
always.
We
were
always
struggling
that
there
was.
There
was
not
much
support
when
cloud
foundry
showed
up
as
a
platform
as
a
cloud
platform
at
the
beginning.
A
The
web
socket
was
not
supported,
it
was
actually
a
problem,
and
that
was
a
a
time
when,
when
we
were
doing
this,
this
project
as
sap,
what
I
told
you
and
kubernetes,
as
far
as
I
remember
the
also
at
the
beginning,
though
the
ingresses
they
were
not
supporting,
websocket
so
yeah.
But
now
it's
time
that
it's,
I
think
it
became
standard
really.
A
A
Something
called
server
sent.
Events-
and
yes,
that's
also
a
solution
here,
but
I
don't
want
to
talk
about
it
mainly
because
it's
it's
mainly
about
web
socket
right.
So,
let's
not,
let's
not
go
into
the
different
alternatives,
not
not
this
time,
not
today,
so
yeah
now
async
api,
and
I
hope
that
you
I
mean
really.
My
assumption
is
that
you
already
know
a
bit
about
asympto.
A
A
A
A
A
A
A
Which
is
like
designed
to
work
with
websocket,
you
can
think
about
it
as
a
curl
for
websocket.
I
think
so.
I
have
it
installed
already
and
yeah.
Look.
Look
how
easy
it
is
so
kraken
the
cool
stuff
about
those
cryptocurrency
trading
companies
is
that
they
provide
a
lot
of
data
without
any
need
to
be
authorized.
A
A
Sorry
yeah
website
is
here
so
yeah,
let's
paste
the
the
command.
So
what
I'm
doing
here
is
I'm
using
websocket
to
actually
call
websocket
api
from
kraken
and
I'm
connecting
to
it
on
using
websocket
protocol.
But
wss
means
like
in
with
http.
You
have
http
and
https
the
same
with
websocket,
ws
or
wss,
which
means
that
wss
is
encrypted.
A
A
A
Okay,
before
I
jump
so
rodrigo
specified,
it
was
about
mercure,
so
thanks
rodrigo,
hey,
hey
aarin.
So
looking
on
my
past
experience
because
I
needed
websocket,
we
needed
a
new
app
socket
for
front-end,
so
yeah.
We,
we
were
usually
thinking
about
websocket
channels
that
you
need
for
for
a
given
view.
So
when
I
had
a
view
of,
I
don't
remember
what
it
was
like
projects,
then
I
was
only
expecting
projects
to
be
sent
to
me
by
the
server.
A
A
Currency
and
now
it's
it's
probably
stupid
and
doesn't
make
sense
much
so
sorry,
if
it's
confusing
for
you,
but
let's
say
what
you
see
here,
is
that
I'm
using
query
power,
not
query,
I'm
I'm
query.
Parameters
would
be
here,
but
I
can.
I
can
connect
to
a
given
endpoint
with
just
currency
updates
and
specify
the
the
name
of
the
currency
which
is
pln,
which
is
polish
currency
and
then,
after
connecting,
I
would
expect
a
stream
of
data
most
up
to
date,
but
yeah
with
the.
A
Recently,
I
noticed
many
people
use
sub
protocols
with
websocket,
so
websocket
is
just
to
enable
you
this
connection
and
and
this
bi-directional
way
of
working
but
internally
those
messages
follow
a
a
sub
protocol.
You
just
agree
on
some
sub
protocol
that
that
defines
rules
how
you
can,
through
one
connection,
subscribe
to
different
messages
and
receive
them
from
the
server.
A
A
A
A
I'm
sending
a
message
that
I
want
to
subscribe,
my
client
to
ticker
updates
for
this
from
that
currency
to
this
one
and
that
to
this
one
and
as
you
can
see,
I'm
getting
a
stream
of
messages
with
most
up-to-date
information
about
the
prices
and
from
time
to
time
I
got
another
event
which
is
a
heartbeat
to.
Let
me
know
that
the
I
still
have
the
connection
with
the
with
the
websocket
api.
A
A
A
A
A
A
A
A
A
Now
there
are
channels
that,
where
you
specify
this,
like
a
connection
points
with
the
server
with
your
application,
where
you
can
consume
or
or
publish
on
which
channel
you
can
consume
messages
and
publish
messages
and
what
kind
of
messages
so
it's
let's
say
channel
is-
is
the
meat
right?
It's
the
central
point
here,
then
it's
id
but
yeah.
Let's
not
it's
not
so
important
to
to
tackle
an
external
dog
stacks.
Of
course
it's
useful
for
for
rendering
of
documentation,
for
example,.
A
A
Some
specific
objects
in
the
payload,
or
not
an
object
such
as
just
some
id
or
something
so,
instead
of
repeating
the
same
id
in
all
the
payloads
like,
let's
say
you
have
20
messages
in
20
payloads.
You
just
provide
schema
for
this
id
once
in
the
components
and
then
you
can
refer
to
this
schema
from
other
schemas.
So
that's
the
that's
the
point
about
components
now
info
so
in
case
of
yeah
kraken
api.
That
was
super
super
easy
to
do
just
copy
paste
from
the
official
docs.
A
So
you
can
what
you
can
do
with
info.
You
provide
the
title,
the
name
of
the
api,
the
version
of
the
api
and
some
description.
You
can
do
it
in
markdown,
as
I
did
it
here,
but
the
most
important
is
what
you
should
notice.
When
I
I
talk
about
async
api,
I
always
say
like
your
application,
your
application,
the
application
that
you
describe.
A
A
A
You've
got
a
server
that
requires
authentication,
and
you
also
have
beta
servers
with
some
better
functionality.
So
I
completely
ignored
those
I
didn't
put
them
in
the
document,
because
it's
super
specific
to
your
use
cases,
how
you
provide
beta
solutions
if
you
really
provide
them
as
separate
servers,
or
rather
hidden
behind
some
future
flags.
A
So
it's
not
for
me
to
judge
how
they
do
it
for
sure
you
can't
just
yeah
generate
different
code
for
the
official
endpoint,
the
official
server
and
then
some
beta
server
with
some
different
different
solutions,
different
features,
so
I've
put
public
and
private
now
the
the
private
stuff
that
was
that
was
a
problem
for
me.
I
could
not
figure
out
using
their
documentation
how
they
do
the
security
of
the
server.
A
A
So
yeah
now
why
I
choose
to
provide
public
and
private
here
in
one
document
if
in
the
end
they
provide
different
functionalities
and
that's
how
it
is
with
kraken.
So
some
information
that
you'd
like
to
read
from
the
server
is
not
available
on
on
the
public
server.
It's
only
on
the
private
server,
where
you
need
to
authenticate
to
get
your
probably
some
private
information.
A
A
But
to
make
it
super
simple,
I
decided
that
I'm
doing
this,
let's
say
mistake
that
I
described
at
the
beginning
and
I
spent
time
on
learning
spec
only
to
create
as
an
api
document
to
generate
docs,
which
again
it's
not
the
you
should
use
it
for
more
things.
But
so
I
said
okay,
I
just
want
to
generate
talks.
So
that's
why,
from
my
perspective,
it's
better
to
just
describe
those
two
servers
in
one
asking
api
document
to
have
one
one
view:
information
in
one
view,
but
normally
for
code
generation.
A
A
Because
with
asking
api,
it's
also
possible,
so
we
can
like
again
like
this
is
just
one
document
for
kraken,
but
I
could
have
two
documents:
one
for
public,
one
for
private
in
the
public
document
that
that
exposes
the
public
server.
I
could
describe
just
the
things
that
are
only
available
on
the
public.
A
Now,
with
the
private,
with
the
document
for
the
private
server
of
the
private
part
of
the
api,
I
could
describe
only
the
the
private
stuff
and
describe
how
to
authenticate
etc.
Now
they
both
have
some
messages
in
common,
like
ping
pong
heartbeat,
and
it's
not
a
problem,
you
don't
have
to
duplicate
them.
A
In
those
two
documents
you
can
have
common
parts
because,
like
with
async
api,
you
can
we
we
take
advantage
of
dollar
ref
property,
so
you
can
reference
external
files
from
url
from
from
local
drive
from
inside
the
document
or
to
a
specific
part
of
the
document.
So
you
can
reuse
things
so,
most
probably
on
production.
When
I
would
really
work
on
on
kraken
api
asking
api
document,
I
would
strongly
consider
writing
too.
A
There's
just
one
single
connection
point
and,
as
I
said,
there's
probably
some
sub
protocol.
They
agreed
up
on
how
the
subscription
to
given
messages
work
now
going
back
to
asking
api
document.
This
means
we
have
just.
You
have
an
application
that
has
a
single
channel
and
if
it
doesn't
have
a
name
like
in
case
of
the
server
endpoints
paths,
whatever
there's
nothing
like
you
connect
to
the
server
on
the
root.
A
A
A
A
Now
what
is
operation
id-
and
that
is
here
now-
I
did
not.
I
I've-
put
it
in
this
document,
although
I
think
it's
not
really
needed,
especially
that
operation
id
is
mainly
for
for
code
generation,
because
when
I
was
creating
this
document,
I
was
not
thinking
about
code
generation
this.
This
operation
id,
is
not
very
needed
very
much
needed
because
you
use
it
like
in
code
generation.
When
you
want
to
have
some
defined
names
of
functions
of
handlers,
that
will
consume
message
and
that
will
process
messages.
A
A
A
A
So
that's
that's
super
important.
It's
not
that
confusing
and
it
makes
sense
with
websocket
when
you
have
client
and
a
server
like
with
open
api
and
rest
api.
You
have
client
on
the
server,
but
if
you
use
asking
api
for
architectures,
where
the
client
does
not
connect
directly
to
the
server
but
there's
a
a
broker,
a
message
broker
in
the
middle,
that's
highly
confusing.
A
A
A
Section
so
messages
the
pink
message:
what
I
can
do
with
this
pack.
I
can,
of
course,
provide
some
short
summary,
some
description,
which
is
very
important,
some
reference
to
the
payload
so
to
the
schema,
and
now,
let's
talk
about
this
schema,
so
async
api
allows
you
to
to
provide
information
about
the
payload
of
the
message
using
different
schema
formats.
A
A
Payload
description
into
asking
api
document
or
you
can
reuse
the
the
schema
information
about
the
open
up
open
api
document.
So
if
you
have
already
revised
api
with
some
with
schemas
already
defined-
and
you
want
to
reuse
because
the
messages
will
look
the
same,
you
want
to
reuse
those
schemas
in
your
application.
Where
that
only
talks
through
a
like
even
driven
interface,
so
talks
to
some
some
broker
or
websocket
endpoint,
then
you
can
reuse
those
schemas
between
those
two
documents.
A
A
Okay,
so
we
can
see
pink,
so
it's
an
it's
an
object
and
it
has
two
properties
where
event
is
the
required
one
and
it's
always
pink
and
there's
always
a
request
id.
You
remember
when
I
told
you
about
that
when
you
have
some
id
that
is
the
same
across
all
the
messages
you
can
reuse.
So
again,
you
can
see.
Oh
wait,
sorry,
so
we
can
see
that
even
inside
components
inside
schema
inside
components,
you
can
refer
to
different
schemas
in
the
components.
So
it's
yeah
for
reusability.
A
A
A
Even
driven
architectures,
it's
a
really
complex
beast.
You
have
many
different
paradigms
there.
You
have
many
different
protocols
there,
it's
not
as
easy
as
with
open
api
and
rest
api,
because
open
apis
is
for
rest,
api.
Just
one
protocol,
that's
simple:
we've
even
driven
our
architectures
there's
just
like
a
huge
amount
of
protocols.
A
A
So
the
idea
is
that,
with
extensions,
you
can
not
wait
for
you,
don't
have
to
wait
for
the
spec
until
it
supports
something
you
can
already
start
using.
Something
like
describe
something
extra
in
your
document
and
a
a
small
information
here.
So
we,
whenever
you
want
to
add
something
to
the
spec
like
we
always
encourage
like
try.
Extensions
first
share
the
extension
with
others
and
see
how
it
goes
and
we
have.
A
A
So
that's
basically
the
idea
for
the
for
the
extensions
that
you
could
follow,
but
yeah.
Let's
focus
on
this
x
response,
so
something
that
you
don't
need.
I
don't
think
you
need
it
with
when
you
have
message
broker
somewhere
in
the
middle,
because
with
message
broker,
you
just
send
a
message
to
the
broker
and
you
don't
care
what's
happening
next,
unless
you
use
nuts,
then
that's
different.
So
in
nuts,
but
not
only
nuts
in
websocket,
you
want
to
know
what's
the
response
when
you
send
a
given
message.
A
So
how
do
I
know
that,
after
sending
to
the
server
pink
message,
I'm
gonna
receive
a
punk
message,
because
here
what
I
can
see
now
I
just
I
just
know
that
I
can
publish
multiple
different
messages
and
I
can
subscribe
to
many
different
messages,
but
there's
no
way
to
say.
Okay,
when
I
say
senping,
I
get
pong
when
I
send
a
subscribe,
I'm
gonna
get
heartbeat
and
and
a
subscription
status,
and
that's
where.
A
A
The
advantage
of
extensions
is
that
you
can
you
can
explore
you
don't
have
to
wait
for
the
spec
to
evolve.
You
can
actually
see
how
it's
it's
gonna
work
for
you
and
then
it's
even
better
for
us,
I
mean
you're
gonna
suggest
us
a
change
in
the
spec
by
just
providing
examples
of
what
extension
you
got,
how
it
works
for
you
and
what
are
the
the
advantages
of
a
given
solution.
A
A
A
In
the
in
the
playground,
so
if
I
use
reference
to
existing
message
of
course
now
it's
not
the
nicest,
because
it's
a
response,
it's
a
it's
a
reference,
some
unknown
property,
so
we
dump
entire
subscription
status.
Message
object!
Oh
wait!
It's
not
that
we
should
check
the
punk.
Sorry
where's,
the
pink
yeah
punk,
so
we
we
show
the
entire
object
representing
punk
message,
but
in
few
days
there's
going
to
be
an
update
in
the
playground
thanks
to
magic,
and
he
actually
is
doing
some
magic
here.
A
A
Since
one
and
a
half
month
we're
part
of
linux
foundation.
We
have
an
open
governance
model,
so
we
want
to
work
on
the
on
the
spec
on
next
versions.
With
the
with
the
community,
we
have
a
clear
contributing
guide,
pretty
fresh
that
we
copied
from
from
graphql
that
describes
well
how
to
get
changes
into
the
spec.
So
I'm
going
to
send
it
to
you
also
in
the.
A
Most
important
is,
I
don't
think
we
made
a
decision
yet,
but
I
haven't
seen
any
comments
in
the
issue,
so
it
looks
like
we're
releasing
on
in
june
a
2.1
version
of
the
of
the
spec
and
the
changes.
I
know
that
are
already
proposed:
they're
not
coming
from
actually
main
maintainers
of
asking
api
it's
coming
from
the
community.
A
Give
us
a
heads
up,
provide
issues,
describe
your
use
cases,
what
what
is
missing
in
your
case.
What's
the
use
case,
for
you
show
how
you
use
it
with
your
extensions
and
then
then,
let's,
let
us
improve
the
spec,
but
at
least
the
cool
stuff
is
that
you
can
always
find
a
a
kind
of
workaround
for
that.
A
A
A
A
And
the
trade-offs-
sometimes
you
have
to
take
because
not
all
way,
not
always
all
the
features
of
of
json
schema
are
supported,
for
example,
in
in
async
api
tooling.
Not
all
the
cases
are
yet
supported,
so
sometimes
you
have
to
make
trade-offs
and
and
choose
different
ways
to
express
the
same
thing
which
in
the
end,
it's
it's
fine
as
long
as
it's
technically,
not
meaning
something
different.
A
A
A
A
You
are
so
in
the
meantime.
Yeah
is
gemini
again
cryptocurrency
and
by
the
way
I
was
not
I
this.
This
stream
is
not
supported
by
cryptocurrency
companies,
but
I
like
them
because
they
expose
their
apis
without
authentication,
which
is
super
cool
for
learning
love
you
guys,
so
they
have
a
public
market
data.
Api.
Oh
and
you
see
that's
give
me
a
second
like
see
this
private
public
different
apis.
So
again
you
can
see
there
are
different
ways
of
expressing
here
so
in
in
kraken.
A
It's
it
says
it's
like
it's
like
one
api,
it's
marketed
as
one
api
with
public
and
private
servers
here,
it's
it's
clear
that
it's
private
api
and
public
api
like
two
different
apis.
Okay,
so
it's
super!
I
I
prefer
gemini
a
way
because
it's
cleaner.
In
my
opinion,
you
I
mean
my.
I
have
a
lot
of
background
in
technical
writing
and
content
architecture,
and
I
know
that
from
user
perspective
it
makes
you
focused
on
on
given
functionality
only
you're
not
thrown
into
everything
at
the
same
time
but
yeah.
A
There
are
different
schools
for
that.
So
gemini
I
I
looked
at
gemini
because
they,
their
v1
version
of
the
api,
is
totally
different
than
the
kraken
and
their
v2
version
of
the
api
seems
like
following
the
same
pattern
as
as
kraken
api
took
so
a
single
connection
point
and
some
sub
protocol
used
internally.
A
That
defines
how
you
can
subscribe
or
unsubscribe
for
given
messages,
but
v1
is
like
totally
opposite
like
something
that
I'm
used
to
from
my
previous
experience
with
the
api.
So
this
stuff
is
super
super
different
here.
So
let
me
go
here,
so
we
talked
about
kraken
and
yes,
I
have
a
async
api
document
for
shrek
up,
but
that
seems
different
on
the
different
block,
a
different
stream,
but
I
have
game
mini
so.
A
A
A
Got
one
channel
we
got
one
channel
like
in
case
of
kraken,
but
we
could.
We
could
have
more
in
the
in
the
channel.
You
can
see
something
extra.
It's
not
just
a
it's,
not
just
a
slash.
It's
not
just!
You
can't
access
the
the
server
data
on
a
on
a
root.
You
actually
access
it
on
a
given
endpoint,
and
you
have
even
some
dynamic
properties
here,
parameters
here
so,
depending
on
a
given
parameter,
you're,
giving
getting
different
answers
from
the
from
the
server.
So,
let's
first
maybe
let's
just
trigger
the
api.
A
A
A
The
definition
of
the
symbol,
it's
again
something
much
more
complicated,
but
yeah
you
can
see
it's
somehow
referring
the
the
cryptocurrency
name
and
the
and
real
current
like
real,
like
crypto,
is
not
real
but
yeah
like
the
normal
usual,
whatever
old
currency
name.
Now,
as
you
can
see,
I
have
also
query
parameters
and
I
don't
have
them
here
in
the
name
of
the
channel,
because
query
parameters,
that's
something
super
specific,
only
to
rest
api
or
websocket.
A
But
here
you
see
a
new
key
in
the
document
which
is
called
bindings
and
it's
a
way,
nothing
api
to
provide
custom
protocol
information
into
a
single
api
document
so
to,
and
it
makes
the
asking
api
document
a
protocol
agnostic.
So
we
can,
as
you
can
see,
using
basic
features
of
the
async
api.
I
could
describe
kraken
api,
but
sometimes
you
need
some
specific
protocol
information
like
query
parameters
that
you
have
to
provide
inside
the
bindings.
A
A
We
have
a
list
of
all
the
bindings
for
all
the
protocols
also
maintained
by
the
assembly
engine
I
mean
I
seriously
have
to
explore.
What's
happening
with
my
mic,
so
as
you
can
see,
there
are
many
on
the
list,
but
the
list
is
not
closed.
So
if
there's
some
protocol,
you
don't
see
on
the
list
and
you
want
to
contribute
the
specification
of
the
binding
for
a
given
protocol.
A
It
describes
what
kind
of
additional
information
specific
for
websocket
you
can
provide
on
a
channel
level
and
that's
what
I'm
using
here
in
the
in
the
gemini
document.
So
I
specify
the
binding
version,
of
course,
that
I'm
using
and
there's
this
query
property,
which
should
be
a
a
a
schema
that
describes
different
query
parameters
that
can
be
passed
in.
A
A
A
A
A
We
have
protocol
specific
information
here
about
websocket,
so
we
know
what
query
parameters
we
can
use
when
connecting,
and
we
know
that
we
can
we're
gonna
as
a
client.
We
can
only
receive
information
from
the
server,
so
there's
no
way
to
send
the
messages
that
I'm
sending
to
the
to
this
server
to
gemini
api.
A
A
Of
a
given
structure,
so
that's
something
super
natural
for
me.
As
I
said
like
from
the
front-end
expert
experience
I
had
in
the
past.
That's
what
I
would
expect
at
first
right,
some
clear
end
point
I
connect
to
with
some
query
parameters,
and
then
I
get
a
stream
of
data
and
that's
it.
I
don't
have
to
learn
any
sub
protocol
or
whatever
how
to
get
access
to
some
more
messages.
A
If
gamini
had
the
old
way
in
v1
and
jumped
into
v2
following
the
pattern
from
kraken,
I
think
it's
basically
because
makes
sense
because
you
don't
consume
this
information
only
now
in
the
front
end
just
to
build
some
nice
ui
or
mobile
app.
I
bet
that
most
of
the
consumers
of
this
data
is
are
bots,
some
servers
that
can
actually
it's
better
for
them
and
much
more
scalable
to
interact
with
the
api
through
some
sub
protocol.
A
A
Solutions
now,
last
but
not
least,
is
the
the
payload
of
the
message
again,
I'm
not
gonna,
I'm
not
gonna
go
now
into
this
again
of
the
schema.
It's
super
specific
on
the
use
case.
This
schema
was
also
com,
a
bit
complicated,
so
it
yeah
I'm
using
all
of
and
one
of
here,
because
the
structure
of
the
message
can
be
different
depending
on
the
parameter
required
parameters
that
you
pass,
but
I
think
the
most
important
here
is
this
part.
A
Examples
which
are
super
important
and
like
I'd
like
to
explicitly
encourage
you
that
whenever
you
provide
your
async
api
document,
and
you
provide
information
about
the
payload
of
your
of
your
message,
you
should
still
explicitly
provide
nice
examples.
Don't
count
on
any
generators.
Example
generators
to
do
it
for
you,
because
they
will
never
do
it
better
than
if
you
would
add
them
manually,
and
the
advantage
of
adding
multiple
examples
manually
is
that
you
can,
for
example,.
A
By
consuming
asking
api
and
and
enabling
you
with
nice,
testing
and
mocking
solutions,
and
of
course,
if
you
do
some
testing
and
mocking
you,
don't
want
to
mock
with
some
generated
data,
it's
much
better
and
much
easier
to
test
and
and
and
consume.
If
your
examples
are
nicely
structured,
so
always
provide
nice
examples,
that's
what
uncle
lukash
says
now:
that's
that's
it!
If
it
comes
to
gym
mini,
that's
it
if
it
comes
to
gem
mini,
and
I
think
we.
A
A
A
I
think
we
can
still
have.
We
still
have
a
few
minutes
by
the
way
I
mean
you're,
super
silent
in
the
comment
section.
If
you
have
some
questions,
just
feel
free
to
to
shoot
them,
unless
I'm
so
good
in
explaining
things
that
you
don't
need
to
ask
any
questions
which
sounds
good.
So,
let's
see
if
they
I
will
not
read
about
authenticating.
A
A
A
A
A
Hi,
a
timeout
okay,
let's,
let's
try
again
connect
it
and
let's
try
to
subscribe,
not
cool,
guys,
not
cool
polygon,
so
I'm
not
gonna
be
able
to
actually
play
with
them.
If
I'm
not
gonna
be
able
to
play
with
them,
I
don't
want
to
to
go
into
it,
but
anyway,
you
can
see
it's
the
same
pattern
here,
so
they
have
some
sub
protocol
they
use
to.
So
you
you
connect
just
one
channel
there's.
A
A
A
A
I
don't
see
any
questions
in
the
comments.
I'm
super
interested
what
you
think
about
this
way
of
sharing
information,
especially
if
you
don't
watch
don't
read
articles.
Maybe
it's
gonna
be
much
more
interesting
to
watch
the
video
again
so
in
the
chat.
I've
pasted
links
to
all
the
articles
that
I
used
in
this
in
this
live
stream.
A
A
A
A
That
explains
how
to
use
our
node.js
template
for
to
generate
node.js
application,
but
not
for
websocket,
but
purely
for
for
a
solution
where
there's
a
message
broker
somewhere
in
the
middle.
So
I
explain
not
the
async
api
in
general,
but
explain
how
to
actually
use
the
template
where
to
put
your
code,
how
it
works
but
yeah
and
if
it
comes
to
code
generation
about
websocket,
just
a
kind
reminder
again.