All language subtitles for 027 Creating API Documentation Using Postman_Downloadly.ir_en

So, our API is now basically finished.

And so in this final video of the section,

we're gonna quickly create documentation

for API directly in Postman.

And that's right, we can easily create

some quick documentation right in Postman.

And it's really important to have API documentation

in place because this is how we communicate to team members,

or even our final users of the API,

how they can actually use it in practice.

So let me now show you how it works.

Now before we can actually create the documentation,

let's just do some clean up here.

For example, get rid of this request, all right?

Another thing that I want to do is here in the logging in

point, we actually expose our password here.

And so that's not a good idea, and so what I'm gonna do

is to create an environment variable

which is going to hold this password.

Since it's always the same that should be no problem.

So, remember how we do that.

Well we come here to managing the environment

and so here we simply add another one.

So password, test1234.

And here this is not correct, so password, updated,

and now, let's do the same here

in the production one as well.

So password, test1234.

And so, not add, but let's close that

and so here I can now then go add and use that,

not in a string, but like this.

So password.

So let's try that.

And this gives us this weird error,

but our password is actually here so probably what

we need to do is to actually really put the quotes here.

So let's try that.

And so now indeed we're successfully logged in.

So save that now, okay?

And so now what we should do is to actually create

a description for each and every request

that we have in our collection.

Now of course I'm not going to do that,

I will just exemplify it here with the first one.

Okay?

So let's actually close these other ones

and so now here we can add a description.

And so let's just say, use this endpoint

to create a new tour.

Okay, and so again, you should now do this exact same thing

for all of your requests if your goal is to really publish

and share your API, okay?

Then the same thing applies to folders,

and to not rename, but to edit.

And so in each of these folders

we can actually also add a description.

So let's just say, something random like,

you can get all tours,

create new ones,

and edit and delete tours.

There are also special endpoints

for some special requirements.

Okay, so and again this is totally random

and I would publish something like this for my own API,

but here we really just want to test how it works, okay?

As you can see down here,

you can also use Mark down here, okay?

So for example, to make text bold,

you can think it works like this,

yeah it looks like it does,

and so yeah you can do all kinds of stuff here, okay?

You can also probably create a description

on Natours itself, so let's say,

the Natours API contains endpoints

for tours, users, and reviews.

And then again a bunch of stuff,

like you could describe your authentication process,

or your permissions and really everything the user needs

to know in order to use this API, okay?

So you should always add description

to all the requests, to all the folders

and also to, of course, the collection itself.

Oh, and we can actually describe the query parameters

in a query string, so let's do that here.

And we can also say it supports greater than,

less than equal, greater than and less than operators.

So again, just an example here

and let's save it now to the request.

And so with this I think we should be ready

to actually publish our API documentation.

And so for doing that, let's just go here

to the collections option, and then down here,

publish documentations.

And so that should then open up a browser window,

and for me it did outside of my screen

so let me just get that here.

And so now you can choose the environment.

So here we should have a list of our environments,

which for some reason we do not have, that's weird,

but anyway, we didn't want to use any environment anyway,

because that would then replace

our environment variables with their real values,

and we don't want that.

For example, we used the environment variable

on the password, so that then later

in the documentation it's not really visible, okay?

So we really want to use no environment.

Now we could also use a custom domain,

but that's only for paid users, okay?

Then we could also change all of the styling

of the API so to match it with your brand colors,

but again, that's not necessary in this case,

and so, let's actually go ahead and publish it.

And so now, this is actually public,

so everyone can view your documentation now on this URL.

Now for some reason it didn't really update all

the changes that we just did before, so that's a bit weird.

So let's actually go back to Postman

and see what's going on.

Maybe it has to do with this rotating thing here,

so I will just quit Postman and open it again.

And let's hope that fixes it.

So if we now reload here,

ahh then we get all our changes actually here.

So you see, the description that we added

for the Natours collection, okay?

Then also the description for this folder,

and the description for this request.

And finally, as the first description,

also for this parameter, okay?

Here we do then get the URL environment variable

instead of the actual URL.

Now of course, you might want to actually give

the real URL here and for that

you could simply use another environment.

So up here you can actually see all the environments

but they are private, so right now no one can use them,

but remember how in the first step,

we could have actually created this documentation

using one of the environments, and so probably we would have

used the production environment for that and so with that

we would then have the final production URL

here in our API URL's, okay?

Anyway, this is how the documentation looks like,

so here is the example request

and we can change that also to our own language.

So in this case, Node JS, but if the user is

for example doing a request using jQuery,

then they can just use jQuery, okay.

So just to see this example request here, so with Node,

it looks something like this.

So, here we have all our endpoints

and you can see that the ones that require authentication,

they actually have this lock icon here.

And so in your description you could now then add that

saying you need to log in, in order to access this endpoint,

and also how you can actually log in, okay.

Or you can also describe that here

in the authentication section, right?

So ideally, you would have descriptions for all of this.

Oh, and here I see that we actually forgot

to replace the real password but nevermind

as this is really just some example, okay?

But of course, you get all the requests

that we had in our Postman also right here.

Now another nice feature here is this run in Postman button,

and so if someone has Postman installed on their computer,

all they need to do is to click here

and then open with their Postman application.

Now I'm not going to do that right now because of course,

I already have it in my Postman, but otherwise

this is a really nice feature for the users to then go ahead

and right away start experimenting with your API.

Okay, and I think that's it actually

so this wraps up our section

and our API is now finally really completed.

So again, congratulations for making it this far

into the course, we've already covered

so much ground here together.

Now next up, there is a very, very exiting section

ahead where we will finally build

the user face for the Natours website.

So basically, we're going to use templates

to create a completely dynamic website based

on all the data that we already have in our database.

And that's really cool.

And so I can't wait to show that to you.