diff --git a/_data/toc.yaml b/_data/toc.yaml
index a77bb6732b1..0008b4efd4d 100644
--- a/_data/toc.yaml
+++ b/_data/toc.yaml
@@ -479,10 +479,14 @@ toc:
title: wait
- sectiontitle: Engine API
section:
+ - path: /engine/api/
+ title: Overview
+ - path: /engine/api/getting-started/
+ title: Getting started
+ - path: /engine/api/sdks/
+ title: SDKs
- path: /engine/api/v1.25/
title: Reference
- - path: /engine/api/client-libraries/
- title: Client libraries
- sectiontitle: Version history
section:
- path: /engine/api/version-history/
diff --git a/engine/api/client-libraries.md b/engine/api/client-libraries.md
deleted file mode 100644
index e58a3948c25..00000000000
--- a/engine/api/client-libraries.md
+++ /dev/null
@@ -1,131 +0,0 @@
----
-redirect_from:
- - /engine/reference/api/remote_api_client_libraries/
- - /reference/api/remote_api_client_libraries/
-description: Various client libraries available to use with the Docker Engine API
-keywords:
-- API, Docker, index, registry, REST, documentation, clients, C#, Erlang, Go, Groovy, Java, JavaScript, Perl, PHP, Python, Ruby, Rust, Scala
-title: Engine API client libraries
----
-
-These libraries make it easier to build applications on top of the Docker
-Engine with various programming languages. They have not been tested by the
-Docker maintainers for compatibility, so if you run into any issues, file them
-with the library maintainers.
-
-
diff --git a/engine/api/getting-started.md b/engine/api/getting-started.md
new file mode 100644
index 00000000000..80ff41cda42
--- /dev/null
+++ b/engine/api/getting-started.md
@@ -0,0 +1,547 @@
+---
+title: Getting started with the Engine API
+---
+
+To try out the Docker Engine API in development, [you first need to install Docker](https://docs.docker.com/engine/installation/).
+
+Next, you need to install an SDK for the language you are using. There are official ones available for Python and Go, and a number of community maintained libraries for other languages. [Head to the SDKs page to find and install them.](sdks.md)
+
+## Running a container
+
+The most basic thing you can do with Docker is running a container. On the command line, you would use the `docker run` command, but this is just as easy to do from your own apps too.
+
+This is the equivalent of doing `docker run alpine echo hello world`:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+print client.containers.run("alpine", ["echo", "hello", "world"])
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "io"
+ "os"
+
+ "github.com/docker/engine-api/client"
+ "github.com/docker/engine-api/types"
+ "github.com/docker/engine-api/types/container"
+ "golang.org/x/net/context"
+)
+
+func main() {
+ ctx := context.Background()
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ _, err = cli.ImagePull(ctx, "alpine", types.ImagePullOptions{})
+ if err != nil {
+ panic(err)
+ }
+
+ resp, err := cli.ContainerCreate(ctx, &container.Config{
+ Image: "alpine",
+ Cmd: []string{"echo", "hello world"},
+ }, nil, nil, "")
+ if err != nil {
+ panic(err)
+ }
+
+ if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
+ panic(err)
+ }
+
+ if _, err = cli.ContainerWait(ctx, resp.ID); err != nil {
+ panic(err)
+ }
+
+ out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
+ if err != nil {
+ panic(err)
+ }
+
+ io.Copy(os.Stdout, out)
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" \
+ -d '{"Image": "alpine", "Cmd": ["echo", "hello world"]}' \
+ -X POST http:/v1.24/containers/create
+{"Id":"1c6594faf5","Warnings":null}
+
+$ curl --unix-socket /var/run/docker.sock -X POST http:/v1.24/containers/1c6594faf5/start
+
+$ curl --unix-socket /var/run/docker.sock -X POST http:/v1.24/containers/1c6594faf5/wait
+{"StatusCode":0}
+
+$ curl --unix-socket /var/run/docker.sock "http:/v1.24/containers/1c6594faf5/logs?stdout=1"
+hello world
+{% endhighlight %}
+
+
+
+You can also run containers in the background, the equivalent of `docker run -d bfirsh/reticulate-splines`:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+container = client.containers.run("bfirsh/reticulate-splines", detach=True)
+print container.id
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "fmt"
+ "io"
+ "os"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/api/types/container"
+ "github.com/docker/docker/client"
+ "golang.org/x/net/context"
+)
+
+func main() {
+ ctx := context.Background()
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ imageName := "bfirsh/reticulate-splines"
+
+ out, err := cli.ImagePull(ctx, imageName, types.ImagePullOptions{})
+ if err != nil {
+ panic(err)
+ }
+ io.Copy(os.Stdout, out)
+
+ resp, err := cli.ContainerCreate(ctx, &container.Config{
+ Image: imageName,
+ }, nil, nil, "")
+ if err != nil {
+ panic(err)
+ }
+
+ if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
+ panic(err)
+ }
+
+ fmt.Println(resp.ID)
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" \
+ -d '{"Image": "bfirsh/reticulate-splines"}' \
+ -X POST http:/v1.24/containers/create
+{"Id":"1c6594faf5","Warnings":null}
+
+$ curl --unix-socket /var/run/docker.sock -X POST http:/v1.24/containers/1c6594faf5/start
+{% endhighlight %}
+
+
+
+## Listing and managing containers
+
+Like `docker ps`, we can use the API to list containers that are running:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+for container in client.containers.list():
+ print container.id
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/client"
+)
+
+func main() {
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ containers, err := cli.ContainerList(context.Background(), types.ContainerListOptions{})
+ if err != nil {
+ panic(err)
+ }
+
+ for _, container := range containers {
+ fmt.Println(container.ID)
+ }
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock http:/v1.24/containers/json
+[{
+ "Id":"ae63e8b89a26f01f6b4b2c9a7817c31a1b6196acf560f66586fbc8809ffcd772",
+ "Names":["/tender_wing"],
+ "Image":"bfirsh/reticulate-splines",
+ ...
+}]
+
+{% endhighlight %}
+
+
+
+Now we know what containers exist, we can perform operations on them. For example, we can stop all running containers:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+for container in client.containers.list():
+ container.stop()
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "context"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/client"
+)
+
+func main() {
+ ctx := context.Background()
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ containers, err := cli.ContainerList(ctx, types.ContainerListOptions{})
+ if err != nil {
+ panic(err)
+ }
+
+ for _, container := range containers {
+ if err := cli.ContainerStop(ctx, container.ID, nil); err != nil {
+ panic(err)
+ }
+ }
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock http:/v1.24/containers/json
+[{
+ "Id":"ae63e8b89a26f01f6b4b2c9a7817c31a1b6196acf560f66586fbc8809ffcd772",
+ "Names":["/tender_wing"],
+ "Image":"bfirsh/reticulate-splines",
+ ...
+}]
+
+$ curl --unix-socket /var/run/docker.sock \
+ -X POST http:/v1.24/containers/ae63e8b89a26/stop
+
+{% endhighlight %}
+
+
+
+We can also perform actions on individual containers. For example, to print the logs of a container given its ID:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+container = client.containers.get('f1064a8a4c82')
+print container.logs()
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "context"
+ "io"
+ "os"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/client"
+)
+
+func main() {
+ ctx := context.Background()
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ options := types.ContainerLogsOptions{ShowStdout: true}
+ out, err := cli.ContainerLogs(ctx, "f1064a8a4c82", options)
+ if err != nil {
+ panic(err)
+ }
+
+ io.Copy(os.Stdout, out)
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock "http:/v1.24/containers/ca5f55cdb/logs?stdout=1"
+Reticulating spline 1...
+Reticulating spline 2...
+Reticulating spline 3...
+Reticulating spline 4...
+Reticulating spline 5...
+{% endhighlight %}
+
+
+
+## Managing images
+
+Images are the basis of containers, and can be managed in a similar way. You can list the images on your Engine, similar to `docker images`:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+for image in client.images.list():
+ print image.id
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/client"
+)
+
+func main() {
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ images, err := cli.ImageList(context.Background(), types.ImageListOptions{})
+ if err != nil {
+ panic(err)
+ }
+
+ for _, image := range images {
+ fmt.Println(image.ID)
+ }
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock http:/v1.24/images/json
+[{
+ "Id":"sha256:31d9a31e1dd803470c5a151b8919ef1988ac3efd44281ac59d43ad623f275dcd",
+ "ParentId":"sha256:ee4603260daafe1a8c2f3b78fd760922918ab2441cbb2853ed5c439e59c52f96",
+ ...
+}]
+{% endhighlight %}
+
+
+
+You can pull images, like `docker pull`:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+image = client.images.pull("alpine")
+print image.id
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "io"
+ "os"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/client"
+ "golang.org/x/net/context"
+)
+
+func main() {
+ ctx := context.Background()
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ out, err := cli.ImagePull(ctx, "alpine", types.ImagePullOptions{})
+ if err != nil {
+ panic(err)
+ }
+
+ io.Copy(os.Stdout, out)
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock \
+ -X POST "http:/v1.24/images/create?fromImage=alpine"
+{"status":"Pulling from library/alpine","id":"3.1"}
+{"status":"Pulling fs layer","progressDetail":{},"id":"8f13703509f7"}
+{"status":"Downloading","progressDetail":{"current":32768,"total":2244027},"progress":"[\u003e ] 32.77 kB/2.244 MB","id":"8f13703509f7"}
+...
+{% endhighlight %}
+
+
+
+And commit containers to create images from their contents:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+container = client.run("alpine", ["touch", "/helloworld"], detached=True)
+container.wait()
+image = container.commit("helloworld")
+print image.id
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "fmt"
+
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/api/types/container"
+ "github.com/docker/docker/client"
+ "golang.org/x/net/context"
+)
+
+func main() {
+ ctx := context.Background()
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ createResp, err := cli.ContainerCreate(ctx, &container.Config{
+ Image: "alpine",
+ Cmd: []string{"touch", "/helloworld"},
+ }, nil, nil, "")
+ if err != nil {
+ panic(err)
+ }
+
+ if err := cli.ContainerStart(ctx, createResp.ID, types.ContainerStartOptions{}); err != nil {
+ panic(err)
+ }
+
+ if _, err = cli.ContainerWait(ctx, createResp.ID); err != nil {
+ panic(err)
+ }
+
+ commitResp, err := cli.ContainerCommit(ctx, createResp.ID, types.ContainerCommitOptions{Reference: "helloworld"})
+ if err != nil {
+ panic(err)
+ }
+
+ fmt.Println(commitResp.ID)
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ docker run -d alpine touch /helloworld
+0888269a9d584f0fa8fc96b3c0d8d57969ceea3a64acf47cd34eebb4744dbc52
+$ curl --unix-socket /var/run/docker.sock\
+ -X POST "http:/v1.24/commit?container=0888269a9d&repo=helloworld"
+{"Id":"sha256:6c86a5cd4b87f2771648ce619e319f3e508394b5bfc2cdbd2d60f59d52acda6c"}
+{% endhighlight %}
+
+
+
+## What next?
+
+ - [Full documentation for the Python SDK.](https://docker-py.readthedocs.io)
+ - [Full documentation for the Go SDK.](https://godoc.org/github.com/docker/docker/client)
+ - [Full documentation for the HTTP API.](/engine/api/v1.25/)
diff --git a/engine/api/index.md b/engine/api/index.md
new file mode 100644
index 00000000000..693d57c4f3c
--- /dev/null
+++ b/engine/api/index.md
@@ -0,0 +1,109 @@
+---
+title: Docker Engine API and SDKs
+redirect_from:
+ - /engine/reference/api/
+ - /engine/reference/api/docker_remote_api/
+ - /reference/api/
+ - /reference/api/docker_remote_api/
+---
+
+# Docker Engine API and SDKs
+
+The Engine API is the API served by Docker Engine. It allows you to control every aspect of Docker from within your own applications. You to build tools to manage and monitor applications running on Docker, and even use it to build apps on Docker itself.
+
+It is the API the Docker client uses to communicate with the Engine, so everything the Docker client can do can be done with the API. For example:
+
+* Running and managing containers
+* Managing Swarm nodes and services
+* Reading logs and metrics
+* Creating and managing Swarms
+* Pulling and managing images
+* Managing networks and volumes
+
+The API can be accessed with any HTTP client, but we also provide [SDKs](sdks.md) in Python and Go to make it easier to use from programming languages.
+
+As an example, the `docker run` command can be easily implemented in various programming languages and by hitting the API directly with `curl`:
+
+
+ - Python
+ - Go
+ - curl
+
+
+
+{% highlight python %}
+import docker
+client = docker.from_env()
+print client.containers.run("alpine", ["echo", "hello", "world"])
+{% endhighlight %}
+
+
+{% highlight go %}
+package main
+
+import (
+ "io"
+ "os"
+
+ "github.com/docker/docker/client"
+ "github.com/docker/docker/api/types"
+ "github.com/docker/docker/api/types/container"
+ "golang.org/x/net/context"
+)
+
+func main() {
+ ctx := context.Background()
+ cli, err := client.NewEnvClient()
+ if err != nil {
+ panic(err)
+ }
+
+ _, err = cli.ImagePull(ctx, "alpine", types.ImagePullOptions{})
+ if err != nil {
+ panic(err)
+ }
+
+ resp, err := cli.ContainerCreate(ctx, &container.Config{
+ Image: "alpine",
+ Cmd: []string{"echo", "hello world"},
+ }, nil, nil, "")
+ if err != nil {
+ panic(err)
+ }
+
+ if err := cli.ContainerStart(ctx, resp.ID, types.ContainerStartOptions{}); err != nil {
+ panic(err)
+ }
+
+ if _, err = cli.ContainerWait(ctx, resp.ID); err != nil {
+ panic(err)
+ }
+
+ out, err := cli.ContainerLogs(ctx, resp.ID, types.ContainerLogsOptions{ShowStdout: true})
+ if err != nil {
+ panic(err)
+ }
+
+ io.Copy(os.Stdout, out)
+}
+{% endhighlight %}
+
+
+{% highlight bash %}
+$ curl --unix-socket /var/run/docker.sock -H "Content-Type: application/json" \
+ -d '{"Image": "alpine", "Cmd": ["echo", "hello world"]}' \
+ -X POST http:/v1.24/containers/create
+{"Id":"1c6594faf5","Warnings":null}
+
+$ curl --unix-socket /var/run/docker.sock -X POST http:/v1.24/containers/1c6594faf5/start
+
+$ curl --unix-socket /var/run/docker.sock -X POST http:/v1.24/containers/1c6594faf5/wait
+{"StatusCode":0}
+
+$ curl --unix-socket /var/run/docker.sock "http:/v1.24/containers/1c6594faf5/logs?stdout=1"
+hello world
+{% endhighlight %}
+
+
+
+To learn more, take a look at the [getting started guide](getting-started.md)
diff --git a/engine/api/sdks.md b/engine/api/sdks.md
new file mode 100644
index 00000000000..642e6f1fafa
--- /dev/null
+++ b/engine/api/sdks.md
@@ -0,0 +1,61 @@
+---
+title: SDKs for Docker Engine API
+description: Client libraries for the Docker Engine API.
+keywords:
+- API, SDK, library, Docker, index, registry, REST, documentation, clients, C#, Erlang, Go, Groovy, Java, JavaScript, Perl, PHP, Python, Ruby, Rust, Scala
+redirect_from:
+ - /engine/api/client-libraries/
+ - /engine/reference/api/remote_api_client_libraries/
+ - /reference/api/remote_api_client_libraries/
+---
+
+The Docker SDKs allow you to build applications that can control and manage the Docker Engine. They are interfaces for the [Docker Engine API](index.md), but also contain a number of tools to make it easier to work with the API.
+
+There are official libraries available in Python and Go, and there are a number of community supported libraries for other languages.
+
+## Python
+
+The Docker SDK for Python is available on the Python Package Index (PyPI), and can be installed with PIP:
+
+ $ pip install docker
+
+To see how to start using it, [head to the getting started guide](getting-started.md).
+
+For a full reference, see the [Docker SDK for Python documentation](https://docker-py.readthedocs.io).
+
+## Go
+
+The Docker SDK for Go is a package inside the Docker Engine repository. To use it, you import it:
+
+{% highlight go %}
+import "github.com/docker/docker/client"
+{% endhighlight %}
+
+To see how to start using it, [head to the getting started guide](getting-started.md).
+
+[A full reference is available on GoDoc.](https://godoc.org/github.com/docker/docker/client)
+
+## Other languages
+
+There a number of community supported libraries available for other languages. They have not been tested by the Docker maintainers for compatibility, so if you run into any issues, file them with the library maintainers.
+
+| Language | Library |
+| ------------- |---------|
+| C# | [Docker.DotNet](https://github.com/ahmetalpbalkan/Docker.DotNet) |
+| C++ | [lasote/docker_client](https://github.com/lasote/docker_client) |
+| Dart | [bwu_docker](https://github.com/bwu-dart/bwu_docker) |
+| Erlang | [erldocker](https://github.com/proger/erldocker) |
+| Gradle | [gradle-docker-plugin](https://github.com/gesellix/gradle-docker-plugin) |
+| Groovy | [docker-client](https://github.com/gesellix/docker-client) |
+| Haskell | [docker-hs](https://github.com/denibertovic/docker-hs) |
+| HTML (Web Components) | [docker-elements](https://github.com/kapalhq/docker-elements) |
+| Java | [docker-client](https://github.com/spotify/docker-client) |
+| Java | [docker-java](https://github.com/docker-java/docker-java) |
+| NodeJS | [dockerode](https://github.com/apocas/dockerode) |
+| Perl | [Eixo::Docker](https://github.com/alambike/eixo-docker) |
+| PHP | [Docker-PHP](https://github.com/docker-php/docker-php) |
+| Ruby | [docker-api](https://github.com/swipely/docker-api) |
+| Rust | [docker-rust](https://github.com/abh1nav/docker-rust) |
+| Rust | [shiplist](https://github.com/softprops/shiplift) |
+| Scala | [tugboat](https://github.com/softprops/tugboat) |
+| Scala | [reactive-docker](https://github.com/almoehi/reactive-docker) |
diff --git a/engine/api/v1.25/index.html b/engine/api/v1.25/index.html
index 249a4cdff34..1f9140fd46c 100644
--- a/engine/api/v1.25/index.html
+++ b/engine/api/v1.25/index.html
@@ -1,11 +1,7 @@
---
layout: null
redirect_from:
- - /engine/api/
- - /engine/reference/api/
- - /engine/reference/api/docker_remote_api/
- /engine/reference/api/docker_remote_api_v1.25/
- - /reference/api/
---