# Get Article Version by ID

> GET /v1/kb/versions/{id} · Knowledge base API

Source: https://developer.kustomer.com/api/knowledge-base/get-article-version-by-id

```http
GET https://{orgname}.api.kustomerapp.com/v1/kb/versions/{id}
Authorization: Bearer <API key>
```

## Authorization

Requires any one of these roles: `org.permission.kb.read`; or legacy `org.user.content.kb.read`, `org.user.kb.read`, `org.admin.content.kb.read`, `org.admin.kb.read`. The API key or user must hold at least one of them. Legacy roles predate permission sets and still work.

Returns Article Version matching the Version ID. Includes read-only `relationships.attachments` derived from `htmlBody` `data-media-id` values.

## About Knowledge base articles

An article is one help page in your knowledge base, such as "How to return an order". Each article keeps its own versions for each language, and customers and agents only see the published version in each language.

Articles are the content of a Kustomer knowledge base. Admins write them in the knowledge base editor. Customers read published public articles in the help center and in the chat widget, and agents look up articles, including internal ones, from the agent desktop. An article is a container. The title, `htmlBody`, `slug` and SEO fields live on its versions, with a separate series of versions for each language. The article itself holds what all languages share: `categories`, `knowledgeBases` (where `featured` pins it to that knowledge base's home page), `tags`, `scope`, `hash` (the short ID used in its URL) and `source`, the language it was first written in.

`POST /v1/kb/articles` creates the article and an empty draft in the source language, which defaults to the org's default language. You fill in the draft and publish it. To change the article later, you create a new draft. There is no `DELETE` for articles: send `deleted: true` to `PUT /v1/kb/articles/{id}` to soft-delete one.

#### Versions, languages and publishing

Each language has at most one draft and at most one published version. The version `status` shows which role a version plays:

| `status` | Meaning |
| --- | --- |
| `draft` | The working copy. You can edit it, and customers never see it. |
| `published` | The live version for that language. Its `version` number goes up by one on every publish. |
| `unpublished` | A version that used to be live, kept as history, or one you took offline. |

To add a translation, create a version in the new language. Creating a version when a draft already exists replaces that draft. To publish, send `publishedAt` to `PUT …/versions/{lang}/draft`. You can include final edits in the same request. The previous live version becomes `unpublished`. Add `markOthersOutOfDate: true` to flag every other language as `outdated`, which tells translators to update them. On the article, `latestLangs` summarizes each language's live `status` and its `outdated` flag, and `draftLangs` lists the languages that have a draft.

#### Public and internal articles

`scope` is `public` (the default) or `internal`. Internal articles are only for signed-in Kustomer users. Set `accessTeams` or `accessUsers` on a draft to limit an internal article to those teams or users, and the limit takes effect when you publish. Admins can always see every article.

The `/p/v3` endpoints are the customer view. They need no API key and only return published, public versions in the requested `lang`. They work out the org from the host, so call your org host, `https://<org>.api.kustomerapp.com` (see [Regions and base URLs](https://developer.kustomer.com/docs/get-started/regions-and-base-urls)). That host serves the org's default knowledge base; pass `knowledgeBaseId` to read a different one. Each result is a published version: its `id` is the version ID, and the parent article is in `attributes.article`.

#### Scheduling

A schedule publishes a language's draft at a future time. Send `lang`, `publishAt` (at least one minute in the future) and `tz` (an IANA time zone such as `America/New_York`). The article must already have a draft in that language. Each language can have only one schedule, and `{type}` is always `publish`. Publishing by hand or deleting the draft cancels the schedule.

#### Which endpoint to use

| To | Call |
| --- | --- |
| List articles as an agent or admin, or search them by `scope` and `lang` | [`GET /v1/kb/articles`](https://developer.kustomer.com/api/knowledge-base/get-articles) or [`GET /v1/kb/articles/search`](https://developer.kustomer.com/api/knowledge-base/search-articles) |
| Read one article, optionally with its versions and categories | [`GET /v1/kb/articles/{id}`](https://developer.kustomer.com/api/knowledge-base/get-article-by-id) |
| Create an article and its first draft | [`POST /v1/kb/articles`](https://developer.kustomer.com/api/knowledge-base/create-an-article) |
| Change categories, knowledge bases, tags or scope, or delete the article | [`PUT /v1/kb/articles/{id}`](https://developer.kustomer.com/api/knowledge-base/update-article) |
| List or search what customers see, without an API key | [`GET /p/v3/kb/articles`](https://developer.kustomer.com/api/knowledge-base/get-articles-public) or [`GET /p/v3/kb/articles/search`](https://developer.kustomer.com/api/knowledge-base/search-articles-public) |
| Start a new draft or a translation | [`POST /v1/kb/articles/{id}/versions/{lang}`](https://developer.kustomer.com/api/knowledge-base/create-a-version) |
| Edit the draft, or publish it with `publishedAt` | [`PUT …/versions/{lang}/draft`](https://developer.kustomer.com/api/knowledge-base/update-a-draft-version) |
| Discard the draft | [`DELETE …/versions/{lang}/draft`](https://developer.kustomer.com/api/knowledge-base/delete-a-draft-version) |
| Unpublish the live version, or set `outdated` | [`PUT …/versions/{lang}/latest`](https://developer.kustomer.com/api/knowledge-base/update-latest-published-article-version) |
| Remove a language and all its versions | [`DELETE /v1/kb/articles/{id}/versions/{lang}`](https://developer.kustomer.com/api/knowledge-base/delete-versions-of-a-language) |
| Read a language's version history, or one version | [`GET …/versions/{lang}`](https://developer.kustomer.com/api/knowledge-base/get-article-versions-by-language) or [`GET /v1/kb/versions/{id}`](https://developer.kustomer.com/api/knowledge-base/get-article-version-by-id) |
| Schedule, reschedule or cancel publishing | [`POST`](https://developer.kustomer.com/api/knowledge-base/create-article-schedule), [`PUT`](https://developer.kustomer.com/api/knowledge-base/update-article-schedule) or [`DELETE …/schedules/{type}/{lang}`](https://developer.kustomer.com/api/knowledge-base/delete-article-schedule) |

Reads need a knowledge base read role such as `org.user.kb.read`. Writes need `org.admin.kb.write` or the matching `org.permission.kb.*` permission. If two writes to the same article overlap, one can fail with `409 Conflict`; read the article again and retry. List endpoints page with `page` and `pageSize`.

Related: [Knowledge base categories](https://developer.kustomer.com/api/knowledge-base#categories), [Knowledge base tags](https://developer.kustomer.com/api/knowledge-base#tags-knowledge-base), [Routes](https://developer.kustomer.com/api/knowledge-base#routes), [Knowledge bases](https://developer.kustomer.com/api/knowledge-base#knowledge-bases)

### Recipes

#### 1. Publish an article from your own content system

Create a help article from content you manage elsewhere, such as a CMS or a docs repo, and make it live in one pass.

**Step 1.** [`POST /v1/kb/articles`](https://developer.kustomer.com/api/knowledge-base/create-an-article.md). Create the article with its `title`, the `categories` it belongs in, and your own ID as `externalId`. `externalId` must be unique in the org, so a sync that retries after a timeout gets an error instead of a duplicate article. Kustomer also creates an empty draft in the source language. Keep `data.id`; `attributes.source` is the draft's language.

```bash title="cURL"
curl --request POST "https://api.kustomerapp.com/v1/kb/articles" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data "{\"title\": \"How to return an order\", \"categories\": [{\"id\": \"$CATEGORY_ID\"}], \"externalId\": \"cms-4417\"}"
```

```bash title="kusty"
kusty api POST /v1/kb/articles \
  --field title="How to return an order" \
  --field categories:="[{\"id\": \"$CATEGORY_ID\"}]" \
  --field externalId=cms-4417 --fields id,attributes.source
```

**Step 2.** [`PUT /v1/kb/articles/{id}/versions/{lang}/draft`](https://developer.kustomer.com/api/knowledge-base/update-a-draft-version.md). Fill in the draft and publish it in the same request: send the HTML as `htmlBody`, any SEO fields and tag IDs, and `publishedAt`. Without `publishedAt` the draft is saved but stays hidden. The response is the published version; the article's `latestLangs` now shows the language as `published`.

```bash title="cURL"
curl --request PUT "https://api.kustomerapp.com/v1/kb/articles/$ARTICLE_ID/versions/en_us/draft" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data "{\"htmlBody\": \"<p>Start a return from your order page.</p>\", \"metaDescription\": \"Return an order in three steps.\", \"tags\": [\"$TAG_ID\"], \"publishedAt\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\"}"
```

```bash title="kusty"
kusty api PUT /v1/kb/articles/$ARTICLE_ID/versions/en_us/draft \
  --field htmlBody="<p>Start a return from your order page.</p>" \
  --field metaDescription="Return an order in three steps." \
  --field tags:="[\"$TAG_ID\"]" \
  --field publishedAt=$(date -u +%Y-%m-%dT%H:%M:%SZ)
```

> Tags must already exist; find or create them with the [tag endpoints](https://developer.kustomer.com/api/knowledge-base#tags-knowledge-base) first. To change the article later, start a new draft with [`POST …/versions/{lang}`](https://developer.kustomer.com/api/knowledge-base/create-a-version) and publish it the same way.

#### 2. Update a live article and flag its translations

Publish a new version of an article in its source language and mark every translation as needing an update, then find the articles translators should work on.

**Step 1.** [`POST /v1/kb/articles/{id}/versions/{lang}`](https://developer.kustomer.com/api/knowledge-base/create-a-version.md). Start a new draft in the source language with the updated `title` and `htmlBody`. The live version stays up while you work. If a draft already exists in that language, this replaces it.

```bash title="cURL"
curl --request POST "https://api.kustomerapp.com/v1/kb/articles/$ARTICLE_ID/versions/en_us" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"title": "How to return an order", "htmlBody": "<p>Returns are now free for 60 days.</p>"}'
```

```bash title="kusty"
kusty api POST /v1/kb/articles/$ARTICLE_ID/versions/en_us \
  --field title="How to return an order" \
  --field htmlBody="<p>Returns are now free for 60 days.</p>"
```

**Step 2.** [`PUT /v1/kb/articles/{id}/versions/{lang}/draft`](https://developer.kustomer.com/api/knowledge-base/update-a-draft-version.md). Publish the draft with `publishedAt` and `markOthersOutOfDate: true`. The old live version becomes `unpublished`, and every other language's `latestLangs` entry gets `outdated: true`. Those translations stay live until they're updated.

```bash title="cURL"
curl --request PUT "https://api.kustomerapp.com/v1/kb/articles/$ARTICLE_ID/versions/en_us/draft" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data "{\"publishedAt\": \"$(date -u +%Y-%m-%dT%H:%M:%SZ)\", \"markOthersOutOfDate\": true}"
```

```bash title="kusty"
kusty api PUT /v1/kb/articles/$ARTICLE_ID/versions/en_us/draft \
  --field publishedAt=$(date -u +%Y-%m-%dT%H:%M:%SZ) --field markOthersOutOfDate:=true
```

**Step 3.** [`GET /v1/kb/articles`](https://developer.kustomer.com/api/knowledge-base/get-articles.md). To build the translators' queue, page through the articles and keep the languages whose `outdated` is `true`. Publishing a new version in a language clears its flag.

```bash title="cURL"
curl "https://api.kustomerapp.com/v1/kb/articles?page=1&pageSize=100" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```

```bash title="kusty"
kusty api GET /v1/kb/articles --all \
  | jq -r '.data as $a | ($a.attributes.latestLangs // {}) | to_entries[]
      | select(.value.outdated) | [$a.id, $a.attributes.title, .key] | @tsv'
```

> To publish a translation, create a version in that language with [`POST …/versions/{lang}`](https://developer.kustomer.com/api/knowledge-base/create-a-version), then publish its draft the same way. If the translation is fine as it is, clear the flag with `outdated: false` on [`PUT …/versions/{lang}/latest`](https://developer.kustomer.com/api/knowledge-base/update-latest-published-article-version).

#### 3. Schedule an article to go live

Publish a language's draft at a set time, for example to match a product launch, and move the time if the launch slips.

**Step 1.** [`POST /v1/kb/articles/{id}/schedules`](https://developer.kustomer.com/api/knowledge-base/create-article-schedule.md). The article needs a draft in the language first. Send `lang`, `publishAt` (at least one minute ahead) and `tz`, an IANA time zone such as `America/New_York`. Each language can have one schedule.

```bash title="cURL"
curl --request POST "https://api.kustomerapp.com/v1/kb/articles/$ARTICLE_ID/schedules" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"lang": "en_us", "publishAt": "2026-11-03T14:00:00.000Z", "tz": "America/New_York"}'
```

```bash title="kusty"
kusty api POST /v1/kb/articles/$ARTICLE_ID/schedules \
  --field lang=en_us --field publishAt=2026-11-03T14:00:00.000Z --field tz=America/New_York
```

**Step 2.** [`PUT /v1/kb/articles/{id}/schedules/{type}/{lang}`](https://developer.kustomer.com/api/knowledge-base/update-article-schedule.md). To move the launch, send the new `publishAt` and `tz` for the language. `{type}` is always `publish`.

```bash title="cURL"
curl --request PUT "https://api.kustomerapp.com/v1/kb/articles/$ARTICLE_ID/schedules/publish/en_us" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY" \
  --header "Content-Type: application/json" \
  --data '{"publishAt": "2026-11-10T14:00:00.000Z", "tz": "America/New_York"}'
```

```bash title="kusty"
kusty api PUT /v1/kb/articles/$ARTICLE_ID/schedules/publish/en_us \
  --field publishAt=2026-11-10T14:00:00.000Z --field tz=America/New_York
```

**Step 3.** [`DELETE /v1/kb/articles/{id}/schedules/{type}/{lang}`](https://developer.kustomer.com/api/knowledge-base/delete-article-schedule.md). If the launch is called off, delete the schedule; the draft stays as it is. Publishing the draft by hand or deleting it also cancels the schedule.

```bash title="cURL"
curl --request DELETE "https://api.kustomerapp.com/v1/kb/articles/$ARTICLE_ID/schedules/publish/en_us" \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```

```bash title="kusty"
kusty api DELETE /v1/kb/articles/$ARTICLE_ID/schedules/publish/en_us --confirm --yes
```

#### 4. Suggest help articles on your own site

Search the published, public articles from your own contact page or app, without an API key, and link to them in the help center.

**Step 1.** [`GET /p/v3/kb/articles/search`](https://developer.kustomer.com/api/knowledge-base/search-articles-public.md). Call your org host with the customer's words as `term` and the page's language as `lang`. No API key is needed, and only published public versions come back. Each result is a version: `title`, `slug`, `lang` and `hash` are there, and `attributes.article` is the parent article's ID. Pass `knowledgeBaseId` to search a knowledge base other than the default one.

```bash title="cURL"
curl "https://$ORG.api.kustomerapp.com/p/v3/kb/articles/search?term=return%20order&lang=en_us&pageSize=5"
```

```bash title="kusty"
kusty api GET /p/v3/kb/articles/search --base-url "https://$ORG.api.kustomerapp.com" \
  --query term="return order" --query lang=en_us --query pageSize=5 \
  | jq -r '.data[].attributes | [.title, "/\(.lang)/\(.slug)-\(.hash)"] | @tsv'
```

**Step 2.** Link each result to the help center. An article's default address is `/<lang>/<slug>-<hash>` on the knowledge base's domain, such as `https://acme.kustomer.help/en_us/how-to-return-an-order-SywrRTzZu`. EU help centers are on `kustomer.support` instead, and if you serve the help center on a custom domain, use that host.

> The org host works in every region; see [Regions and base URLs](https://developer.kustomer.com/docs/get-started/regions-and-base-urls). To list every public article in a language instead of searching, page through [`GET /p/v3/kb/articles`](https://developer.kustomer.com/api/knowledge-base/get-articles-public) with `lang`.

### Example object

A real record from [`GET /v1/kb/articles/{id}`](https://developer.kustomer.com/api/knowledge-base/get-article-by-id.md):

```json
{
  "type": "article_v2",
  "id": "60254e3ec413ae00571e3c96",
  "attributes": {
    "hash": "SywrRTzZu",
    "title": "New Article",
    "source": "en_us",
    "status": "published",
    "scope": "public",
    "createdAt": "2021-02-11T15:33:18.684Z",
    "updatedAt": "2021-02-11T15:42:02.710Z",
    "modifiedAt": "2021-02-11T15:42:02.710Z",
    "publishedAt": "2021-02-11T15:39:32.217Z",
    "tags": [],
    "categories": [
      {
        "id": "5ede78da9bb5bc0013c35b88",
        "knowledgeBase": "5e15fa56a07888001927f8e5"
      }
    ],
    "knowledgeBases": [],
    "metaTitle": "",
    "metaDescription": "Brand new.",
    "metaKeywords": [
      "Brand",
      "new."
    ],
    "latestLangs": {
      "en_us": {
        "status": "published",
        "outdated": false
      }
    }
  },
  "relationships": {
    "org": {
      "links": {
        "self": "/v1/orgs/5e15fa33623f88001a8e0bb5"
      },
      "data": {
        "type": "org",
        "id": "5e15fa33623f88001a8e0bb5"
      }
    },
    "createdBy": {
      "links": {
        "self": "/v1/users/5e15fa45623f88001a8e0bbb"
      },
      "data": {
        "type": "user",
        "id": "5e15fa45623f88001a8e0bbb"
      }
    },
    "modifiedBy": {
      "links": {
        "self": "/v1/users/5e15fa45623f88001a8e0bbb"
      },
      "data": {
        "type": "user",
        "id": "5e15fa45623f88001a8e0bbb"
      }
    },
    "categories": {
      "data": [
        {
          "type": "category",
          "id": "5ede78da9bb5bc0013c35b88"
        }
      ]
    },
    "accessUsers": [],
    "accessTeams": []
  },
  "links": {
    "self": "/v1/kb/articles/60254e3ec413ae00571e3c96"
  }
}
```

Fields:

- `attributes.hash` (string): The short ID in the article's help center URL. Kustomer generates it unless you send one when you create the article.
- `attributes.title` (string): The article's title in its source language, kept in step with that language's version. Each version has its own `title`, which is what customers see.
- `attributes.source` (string): The language the article was first written in, such as `en_us`. It defaults to the org's default language and must be one of the org's languages.
- `attributes.status` (string): `published` once a version in any language has been published. A new article is `unpublished`, and so is one you take offline everywhere by sending `status: unpublished` to `PUT /v1/kb/articles/{id}`. Check `latestLangs` for each language.
- `attributes.scope` (string): `public` (the default) or `internal`. Changing it on `PUT` also changes the article's live and draft versions.
- `attributes.publishedAt` (string): When a version of this article was last published, in any language.
- `attributes.tags` (array): Knowledge base tag IDs, not names. Each version also has its own `tags`, which are the ones that go live when you publish.
- `attributes.categories` (array): The categories the article appears in, at most 15, each `{ id, knowledgeBase }`. `PUT` replaces the whole list and applies it to the live and draft versions too.
- `attributes.categories[].knowledgeBase` (string): The knowledge base the category belongs to. Kustomer fills it in from the category, so you only send `id`.
- `attributes.knowledgeBases` (array): Knowledge bases that list this article on their home page, each `{ id, featured }`. `featured: true` pins it there. Set it with `PUT /v1/kb/articles/{id}`.
- `attributes.metaTitle` (string): The SEO title from the live version, at most 80 characters. Set it on the draft; it's copied here when you publish.
- `attributes.metaDescription` (string): The SEO description from the live version, at most 160 characters. Set it on the draft; it's copied here when you publish.
- `attributes.metaKeywords` (array): SEO keywords from the live version, set on the draft.
- `attributes.latestLangs` (object): One entry per language that has a live or unpublished version, keyed by language code: `status` (`published` or `unpublished`) and `outdated`.
- `attributes.latestLangs.en_us.outdated` (boolean): `true` when the language needs updating, because another language was published with `markOthersOutOfDate: true` or you set it with `PUT …/versions/{lang}/latest`. Publishing the language clears it.
- `relationships.categories` (object): The same categories as `attributes.categories`, as references.
- `relationships.accessUsers` (array): For an internal article, users who can see it besides admins. Set it on a draft; it takes effect when you publish. If both this and `accessTeams` are empty, every signed-in user can see the article.
- `relationships.accessTeams` (array): For an internal article, teams whose members can see it besides admins. Set it on a draft; it takes effect when you publish.

### Relationships

- Points to **Knowledge base categories** via `relationships.categories` (list): The categories an article appears in, up to 15, possibly in different knowledge bases. Categories don't list their articles except as display order in `positions`; set membership on the article with `PUT /v1/kb/articles/{id}`.
- Points to **Users** via `relationships.accessUsers` (list): Users allowed to see an internal knowledge base article, set on a draft with `accessUsers` and applied when it's published.
- Points to **Teams** via `relationships.accessTeams` (list): Teams whose members are allowed to see an internal knowledge base article, set on a draft with `accessTeams` and applied when it's published.
- Points to **Knowledge bases** via `relationships.knowledgeBases` (list): The knowledge bases that list an article on their home page, from the article's `knowledgeBases` attribute, where `featured` pins it. Which knowledge bases an article appears in at all follows from its categories.
- Points to **Knowledge base tags** via `relationships.tags` (list): The knowledge base tags on an article, stored as tag IDs in the article's `tags` and in each version's `tags`. Renaming a tag changes it on every article that has it.
- Points to **Media** via `relationships.attachments` (list): The media files embedded in an article version, read-only and built from the `data-media-id` attributes in the version's `htmlBody`. Article versions return them in `relationships.attachments`; the article itself doesn't.
- Referenced by **Knowledge base routes** via `relationships.article`: The knowledge base article a route redirects to, when `routableType` is `article`. An article can have many routes; list them with `GET /v1/kb/articles/{id}/routes`.

### Permissions

Fewest roles for a read-only integration: `org.permission.kb.read`. For every endpoint: `org.permission.kb.read`, `org.permission.kb.update`, `org.permission.kb.create`, `org.permission.kb.delete`.

## Path parameters

| Name | Type | Required | Description |
| --- | --- | --- | --- |
| `id` | string | yes | Article Version ID |

## Query parameters

| Name | Type | Required | Description |
| --- | --- | --- | --- |
| `include` | string | no | Include the related article in the version response. Supported value is `article`. |

## Responses

### 200

OK

- `data` (object, required)
  - `type` (string, required)
  - `id` (string, required)
  - `attributes` (object, required)
    - `lang` (string, required)
    - `title` (string, required)
    - `slug` (string, required)
    - `metaDescription` (string, required)
    - `metaKeywords` (array<string>, required)
    - `htmlBody` (string, required)
    - `advanced` (boolean, required)
    - `createdAt` (string, required)
    - `updatedAt` (string, required)
    - `rev` (integer, required)
    - `status` (string, required)
    - `scope` (string, required)
    - `tags` (array<any>, required)
    - `categories` (array<object>, required)
  - `relationships` (object, required)
    - `org` (object, required)
    - `createdBy` (object, required)
    - `article` (object, required)
    - `categories` (object, required)
    - `attachments` (object, required): Read-only media IDs derived from htmlBody data-media-id attributes on save. Always present; data is empty when none. Not a request-body field.
- `included` (array<object>, required)
  - `type` (string, required)
  - `id` (string, required)
  - `attributes` (object, required)
    - `hash` (string, required)
    - `title` (string, required)
    - `source` (string, required)
    - `status` (string, required)
    - `scope` (string, required)
    - `createdAt` (string, required)
    - `updatedAt` (string, required)
    - `modifiedAt` (string, required)
    - `publishedAt` (string, required)
    - `tags` (array<any>, required)
    - `categories` (array<object>, required)
    - `latestLangs` (object, required)
    - `draftLangs` (array<string>, required)
  - `relationships` (object, required)
    - `org` (object, required)
    - `createdBy` (object, required)
    - `modifiedBy` (object, required)
    - `publishedBy` (object, required)
    - `published_en_us` (object, required)
    - `draft_en_us` (object, required)
    - `categories` (object, required)
  - `links` (object, required)
    - `self` (string, required)

```json
{
  "data": {
    "type": "article_version",
    "id": "5de25f4205e621001a90a99d",
    "attributes": {
      "lang": "en_us",
      "title": "Cool Article",
      "slug": "cool-article",
      "metaDescription": "Wow",
      "metaKeywords": [
        "Wow"
      ],
      "htmlBody": "<p>Wow</p>",
      "advanced": false,
      "createdAt": "2019-11-30T12:23:30.011Z",
      "updatedAt": "2019-11-30T12:23:30.015Z",
      "rev": 1,
      "status": "draft",
      "scope": "public",
      "tags": [],
      "categories": [
        {
          "id": "5d66d8a02b22ca00f1a5aab6",
          "knowledgeBase": "5daf785c124be4f2960c9a4b"
        }
      ]
    },
    "relationships": {
      "org": {
        "links": {
          "self": "/v1/orgs/57504f64d76808100089eb44"
        },
        "data": {
          "type": "org",
          "id": "57504f64d76808100089eb44"
        }
      },
      "createdBy": {
        "links": {
          "self": "/v1/users/57504f644c80120f00f3c378"
        },
        "data": {
          "type": "user",
          "id": "57504f644c80120f00f3c378"
        }
      },
      "article": {
        "data": {
          "id": "5de25efeffe329001a9b5e93",
          "type": "article_v2"
        },
        "links": {
          "self": "/v1/kb/articles/5de25efeffe329001a9b5e93"
        }
      },
      "categories": {
        "data": [
          {
            "type": "category",
            "id": "5d66d8a02b22ca00f1a5aab6"
          }
        ]
      },
      "attachments": {
        "data": []
      }
    }
  },
  "included": [
    {
      "type": "article_v2",
      "id": "5de25efeffe329001a9b5e93",
      "attributes": {
        "hash": "Sk8y1gaB",
        "title": "Cool Article",
        "source": "en_us",
        "status": "published",
        "scope": "public",
        "createdAt": "2019-11-30T12:22:22.254Z",
        "updatedAt": "2019-11-30T12:23:30.011Z",
        "modifiedAt": "2019-11-30T12:23:30.011Z",
        "publishedAt": "2019-11-30T12:23:17.186Z",
        "tags": [],
        "categories": [
          {
            "id": "5d66d8a02b22ca00f1a5aab6",
            "knowledgeBase": "5daf785c124be4f2960c9a4b"
          }
        ],
        "latestLangs": {
          "en_us": {
            "status": "published",
            "outdated": false
          }
        },
        "draftLangs": [
          "en_us"
        ]
      },
      "relationships": {
        "org": {
          "links": {
            "self": "/v1/orgs/57504f64d76808100089eb44"
          },
          "data": {
            "type": "org",
            "id": "57504f64d76808100089eb44"
          }
        },
        "createdBy": {
          "links": {
            "self": "/v1/users/57504f644c80120f00f3c378"
          },
          "data": {
            "type": "user",
            "id": "57504f644c80120f00f3c378"
          }
        },
        "modifiedBy": {
          "links": {
            "self": "/v1/users/57504f644c80120f00f3c378"
          },
          "data": {
            "type": "user",
            "id": "57504f644c80120f00f3c378"
          }
        },
        "publishedBy": {
          "links": {
            "self": "/v1/users/57504f644c80120f00f3c378"
          },
          "data": {
            "type": "user",
            "id": "57504f644c80120f00f3c378"
          }
        },
        "published_en_us": {
          "data": {
            "type": "article_version",
            "id": "5de25efeffe329001a9b5e94"
          }
        },
        "draft_en_us": {
          "data": {
            "type": "article_version",
            "id": "5de25f4205e621001a90a99d"
          }
        },
        "categories": {
          "data": [
            {
              "type": "category",
              "id": "5d66d8a02b22ca00f1a5aab6"
            }
          ]
        }
      },
      "links": {
        "self": "/v1/kb/articles/5de25efeffe329001a9b5e93"
      }
    }
  ]
}
```

### 400

Bad Request

### 401

Unauthorized

### 403

Forbidden

### 404

Not Found

## Example request

```bash
curl --request GET \
  --url 'https://api.kustomerapp.com/v1/kb/versions/5de25f4205e621001a90a99d' \
  --header "Authorization: Bearer $KUSTOMER_API_KEY"
```