Kroki

https://docs.kroki.io/kroki
Admin
Kroki is a unified HTTP API that converts plain text diagrams into images, supporting a wide range...
Tokens:18,058
Snippets:149
Trust Score:9.6
Update:10 months ago
Show doc for...
Tokens:
Raw
### Download Kroki Kubernetes Definition Files with wget

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet demonstrates how to download the example Kroki Kubernetes definition bundle using the `wget` command. Ensure `wget` is installed on your system. The output is saved to `kroki-k8s-multipod.zip`.

```bash
wget http://docs.kroki.io/kroki/setup/_attachments/kroki-k8s-multipod.zip -O kroki-k8s-multipod.zip
```

--------------------------------

### Run Kroki Standalone Server

Source: https://docs.kroki.io/kroki/setup/manual-install

Starts the Kroki standalone server using the downloaded JAR file. The server defaults to port 8000, but this can be configured via environment variables or Java system properties.

```shell
java -jar kroki-server.jar
```

--------------------------------

### Install Excalidraw Service Individually with kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet shows how to individually install the Excalidraw service for Kroki on Kubernetes using `kubectl apply`. It applies both the deployment and service configuration files directly from GitHub URLs. Ensure `kubectl` is installed and configured.

```bash
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/excalidraw-deployment.yaml
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/excalidraw-service.yaml
```

--------------------------------

### Install Kroki Kubernetes Objects in Batch with kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet illustrates how to install all required Kubernetes objects for Kroki in a single batch operation using `kubectl apply`. Replace `/path/to/kroki-k8s` with the actual path to the directory containing the definition files. Ensure `kubectl` is installed and configured.

```bash
kubectl apply -f /path/to/kroki-k8s
```

--------------------------------

### Install Kroki Service Individually with kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet demonstrates how to individually install the core Kroki service on Kubernetes using `kubectl apply`. It applies both the deployment and service configuration files directly from GitHub URLs. Ensure `kubectl` is installed and configured.

```bash
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/kroki-deployment.yaml
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/kroki-service.yaml
```

--------------------------------

### Validate Kroki Installation with Kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

Verify that Kroki pods are running after installation using `kubectl get pod`. Then, forward a local port to the Kroki service using `kubectl port-forward` to make it accessible on localhost. Finally, test the service with `curl` to ensure diagrams are generated correctly.

```shell
kubectl get pod
```

```shell
kubectl port-forward service/kroki 8000:8000
```

```shell
curl http://localhost:8000/seqdiag/svg/eNorTi1MyUxMV6jmUlBIKsovL04tUtC1UyhPTQKyyoCc6JzEpNQcBVsFJXfXEAX9zLyU1Aq9jJLcHKVYayQ9Nrq6CE3WhA0L8A8GmpaUk5-un5yfm5uaVwIxD6EWqDElsSQxKbE4FUmfp1-wa1CIAg49IFfANOFxXS0A68hQUg==
```

--------------------------------

### Kroki GET Request Example

Source: https://docs.kroki.io/kroki/setup/usage

This is an example of a Kroki GET request. The diagram definition is encoded using deflate + base64 and placed in the URL path, followed by the desired output format.

```http
GET /graphviz/svg/eNpLyUwvSizIUHBXqPZIzcnJ17ULzy_KSanlAgB1EAjQ
```

--------------------------------

### Install BPMN Service Individually with kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet demonstrates how to individually install the BPMN service for Kroki on Kubernetes using `kubectl apply`. It applies both the deployment and service configuration files directly from GitHub URLs. Ensure `kubectl` is installed and configured.

```bash
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/bpmn-deployment.yaml
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/bpmn-service.yaml
```

--------------------------------

### Install Kroki Ingress with kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet shows how to install the Ingress resource for Kroki on Kubernetes using `kubectl apply`. This configuration allows external access to the Kroki service. Ensure `kubectl` is installed and configured.

```bash
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/kroki-ingress.yaml
```

--------------------------------

### Install Mermaid Service Individually with kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet shows how to individually install the Mermaid service for Kroki on Kubernetes using `kubectl apply`. It applies both the deployment and service configuration files directly from GitHub URLs. Ensure `kubectl` is installed and configured.

```bash
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/mermaid-deployment.yaml
kubectl apply -f https://raw.githubusercontent.com/yuzutech/kroki/refs/heads/main/docs/modules/setup/examples/k8s-multi-pod/mermaid-service.yaml
```

--------------------------------

### Kroki GET Request with Query Parameter Options

Source: https://docs.kroki.io/kroki/setup/usage

This example shows how to pass diagram options to Kroki via query parameters in a GET request. The options are appended to the URL after the encoded diagram definition.

```http
GET /graphviz/svg/eNpLyUwvSizIUHBXqPZIzcnJ17ULzy_KSanlAgB1EAjQ?key=value
```

--------------------------------

### Configure Kroki using Environment Variables

Source: https://docs.kroki.io/kroki/setup/kroki-cli

This example illustrates setting the Kroki service endpoint and timeout using environment variables before executing a Kroki command. This approach is beneficial for temporary or dynamic configurations.

```bash
KROKI_ENDPOINT=https://localhost:8000 KROKI_TIMEOUT=1m kroki convert hello.dot
```

--------------------------------

### Deploy Kroki using Helm Charts

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

Install Kroki on Kubernetes using Helm charts provided by the cowboysysop repository. Add the repository and then install the chart with a specified release name. Verify the deployment status using `helm status`.

```shell
helm repo add cowboysysop https://cowboysysop.github.io/charts/
helm install my-kroki cowboysysop/kroki
```

```shell
helm status my-kroki --show-resources --show-desc
```

--------------------------------

### Configure Kroki Server with Custom Dot Path

Source: https://docs.kroki.io/kroki/setup/manual-install

Runs the Kroki standalone server while specifying a custom path to the GraphViz 'dot' binary. This is necessary if the 'dot' executable is not in the system's PATH or if you need to use a specific installation.

```shell
java -DKROKI_DOT_BIN_PATH=/path/to/dot -jar kroki-server.jar
```

--------------------------------

### Extract Kroki Kubernetes Definition Files with unzip

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

This snippet shows how to extract the contents of the downloaded `kroki-k8s-multipod.zip` file using the `unzip` command. Ensure `unzip` is installed. The files will be extracted into a directory named `kroki-k8s`.

```bash
unzip kroki-k8s-multipod.zip -d kroki-k8s
```

--------------------------------

### Enable PlantUML File Inclusions in Kroki

Source: https://docs.kroki.io/kroki/setup/configuration

Configures Kroki's safe mode to allow PlantUML to use '!include' and '!includeurl' directives. Set KROKI_SAFE_MODE to 'unsafe' to disable security restrictions. Case-insensitive values are accepted.

```shell
java -DKROKI_SAFE_MODE=unsafe -jar kroki-server.jar
```

--------------------------------

### Download and Extract Kroki Single Pod Configuration

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

Download a zip archive containing Kubernetes configuration files for a simplified Kroki deployment with a single pod. Use `wget` to download the file and `unzip` to extract its contents into a designated directory.

```shell
wget http://docs.kroki.io/kroki/setup/_attachments/kroki-k8s-singlepod.zip -O kroki-k8s-singlepod.zip
```

```shell
unzip kroki-k8s-singlepod.zip -d kroki-k8s
```

--------------------------------

### Configure PlantUML Include Path and Whitelist

Source: https://docs.kroki.io/kroki/setup/configuration

Restricts PlantUML '!include' directives when Kroki is in 'SAFE' mode. Uses KROKI_PLANTUML_INCLUDE_PATH for include directory, KROKI_PLANTUML_INCLUDE_WHITELIST_* for regex whitelisting, and KROKI_PLANTUML_ALLOW_INCLUDE to enable/disable remote URL includes.

```shell
# Example setting include path
```

```shell
KROKI_PLANTUML_INCLUDE_PATH=/path/to/includes
```

```shell
# Example setting a whitelist regex
```

```shell
KROKI_PLANTUML_INCLUDE_WHITELIST_0='^https://example.com/.*'
```

```shell
# Example enabling remote URL includes
```

```shell
KROKI_PLANTUML_ALLOW_INCLUDE=true
```

--------------------------------

### Generate Diagram with GET (Encoded)

Source: https://docs.kroki.io/kroki/setup/http-clients

This endpoint allows you to generate a diagram by sending the encoded diagram source in the URL path. This is useful for shorter diagrams or when GET requests are preferred.

```APIDOC
## GET /<diagram_type>/<output_format>/<encoded_diagram_source>

### Description
Generates a diagram from an encoded source string provided in the URL.

### Method
GET

### Endpoint
`https://kroki.io/<diagram_type>/<output_format>/<encoded_diagram_source>`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of diagram to generate (e.g., 'graphviz').
- **output_format** (string) - Required - The desired output format for the diagram (e.g., 'svg').
- **encoded_diagram_source** (string) - Required - The Base64 encoded source code of the diagram.

### Request Example
```bash
curl https://kroki.io/graphviz/svg/eNpLyUwvSizIUHBXqPZIzcnJ17ULzy_KSanlAgB1EAjQ
```

### Response
#### Success Response (200)
- **image_data** (string) - The generated diagram in the specified output format.
```

--------------------------------

### Set Companion Container Host and Port

Source: https://docs.kroki.io/kroki/setup/configuration

Configures the network address (host and port) for Kroki's companion containers, such as those for Mermaid, BPMN, and Excalidraw. These settings are used to establish communication between the main Kroki server and the specific diagram rendering services.

```shell
KROKI_MERMAID_HOST=127.0.0.1
```

```shell
KROKI_MERMAID_PORT=8002
```

```shell
KROKI_BPMN_HOST=127.0.0.1
```

```shell
KROKI_BPMN_PORT=8003
```

```shell
KROKI_EXCALIDRAW_HOST=127.0.0.1
```

```shell
KROKI_EXCALIDRAW_PORT=8004
```

--------------------------------

### Kroki POST Request with HTTP Header Options

Source: https://docs.kroki.io/kroki/setup/usage

This example demonstrates passing diagram options to Kroki using HTTP headers prefixed with `Kroki-Diagram-Options`. This method is used in conjunction with a plain text diagram definition sent via POST.

```http
POST /graphviz

Accept: image/svg+xml
Content-Type: text/plain
Kroki-Diagram-Options-Key: value

digraph G {
  Hello->World
}
```

--------------------------------

### Uninstall Kroki with Helm

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

Remove a Kroki installation managed by Helm charts. Use the `helm uninstall` command, providing the release name that was used during the installation.

```shell
helm uninstall my-kroki
```

--------------------------------

### Configure Specific PlantUML Conversion Timeout

Source: https://docs.kroki.io/kroki/setup/configuration

Allows setting a specific conversion timeout for PlantUML diagrams, overriding the general `KROKI_CONVERT_TIMEOUT`. This provides granular control over resource usage for specific diagram types. The format for the timeout duration is the same as for `KROKI_CONVERT_TIMEOUT`.

```shell
KROKI_PLANTUML_CONVERT_TIMEOUT=30s
```

--------------------------------

### Configure Kroki Server Listening Address and Port

Source: https://docs.kroki.io/kroki/setup/configuration

Sets the host and port for Kroki server. Can be specified via KROKI_LISTEN environment variable or Java system property. Supports IPv4, IPv6, and UNIX domain sockets. If port is omitted, defaults to 8000. If host is omitted, binds to all interfaces.

```shell
KROKI_LISTEN=127.0.0.1:1234 java -jar kroki-server.jar
```

```shell
java -DKROKI_LISTEN=127.0.0.1:1234 -jar kroki-server.jar
```

```shell
KROKI_LISTEN=[2001:db8:1f70::999:de8:7648:6e8]:1234
```

```shell
KROKI_LISTEN=unix:///var/run/kroki.sock
```

```shell
KROKI_LISTEN=:1234
```

```shell
KROKI_LISTEN=[::]:1234
```

--------------------------------

### Retrieve Encoded Diagram with HTTPie (GET)

Source: https://docs.kroki.io/kroki/setup/http-clients

Demonstrates retrieving an encoded diagram from the Kroki API using HTTPie with a GET request. The diagram is identified by its encoded string. The output format is SVG.

```bash
http https://kroki.io/graphviz/svg/eNpLyUwvSizIUHBXqPZIzcnJ17ULzy_KSanlAgB1EAjQ
```

--------------------------------

### Kroki POST Request with Plain Text and Headers

Source: https://docs.kroki.io/kroki/setup/usage

This example illustrates a Kroki POST request where the diagram is sent as plain text in the request body. The diagram type is specified in the URL, and the output format is defined using the `Accept` header, while `Content-Type` is set to `text/plain`.

```http
POST /graphviz

Accept: image/svg+xml
Content-Type: text/plain

digraph G {
  Hello->World
}
```

--------------------------------

### Encode Diagram with Python for Kroki GET Request

Source: https://docs.kroki.io/kroki/setup/usage

This snippet demonstrates how to encode a GraphViz diagram using Python's zlib and base64 modules for use in a Kroki GET request. It takes plain text input from stdin and outputs a compressed and encoded string suitable for URLs.

```python
cat hello.dot | python -c "import sys; import base64; import zlib; print(base64.urlsafe_b64encode(zlib.compress(sys.stdin.read().encode('utf-8'), 9)).decode('ascii'))"
```

--------------------------------

### Configure Allowed CORS Headers

Source: https://docs.kroki.io/kroki/setup/configuration

Allows additional HTTP headers for Cross-Origin Resource Sharing (CORS) requests beyond the defaults. This is useful when client applications need to send custom headers. The `KROKI_CORS_ALLOWED_HEADERS` environment variable takes a comma-separated list of header names.

```shell
KROKI_CORS_ALLOWED_HEADERS="x-requested-with,x-app-version"
```

--------------------------------

### Adjust Command Execution Timeout

Source: https://docs.kroki.io/kroki/setup/configuration

Sets the maximum time Kroki will wait for a response from an external diagram generation binary. The default is 5 seconds. You can specify durations using various time units (days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds).

```shell
KROKI_COMMAND_TIMEOUT=10s
```

```shell
KROKI_COMMAND_TIMEOUT=1m
```

```shell
KROKI_COMMAND_TIMEOUT=4000ms
```

--------------------------------

### Configure Kroki using kroki.yml

Source: https://docs.kroki.io/kroki/setup/kroki-cli

This snippet shows how to define the Kroki service endpoint and timeout directly within the kroki.yml configuration file. This is useful for persistent configurations.

```yaml
endpoint: 'https://localhost:8000'
timeout: '30s'
```

--------------------------------

### GET /:diagram_type/svg/:encoded_diagram

Source: https://docs.kroki.io/kroki/setup/usage

Converts a diagram to SVG using a GET request with a deflate+base64 encoded diagram string.

```APIDOC
## GET /:diagram_type/svg/:encoded_diagram

### Description
This endpoint converts a diagram to SVG format using a GET request. The diagram source must be encoded using the deflate + base64 algorithm and included as a URL parameter. Diagram options can be passed as query parameters.

### Method
GET

### Endpoint
`/:diagram_type/svg/:encoded_diagram`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of the diagram (e.g., `graphviz`).
- **encoded_diagram** (string) - Required - The diagram source encoded using deflate + base64.

#### Query Parameters
- **key** (string) - Optional - Diagram specific option key.
- **value** (string) - Optional - Diagram specific option value.

### Request Example
```
GET /graphviz/svg/eNpLyUwvSizIUHBXqPZIzcnJ17ULzy_KSanlAgB1EAjQ?option_key=option_value
```

### Response
#### Success Response (200)
Returns the generated SVG image.

#### Response Example
```svg
<svg ...>...</svg>
```
```

--------------------------------

### Uninstall Kroki with Kubectl

Source: https://docs.kroki.io/kroki/setup/use-kubernetes

Remove Kroki from a Kubernetes cluster by using the `kubectl delete` command with the same YAML files used for installation. Specify the path to the Kroki Kubernetes configuration directory.

```shell
kubectl delete -f /path/to/kroki-k8s
```

--------------------------------

### Retrieve Encoded Diagram with cURL (GET)

Source: https://docs.kroki.io/kroki/setup/http-clients

Shows how to retrieve a previously encoded diagram from the Kroki API using cURL with a GET request. The diagram is identified by its encoded string. The output format is SVG.

```bash
curl https://kroki.io/graphviz/svg/eNpLyUwvSizIUHBXqPZIzcnJ17ULzy_KSanlAgB1EAjQ
```

--------------------------------

### Generate Diagram from File (HTTPie)

Source: https://docs.kroki.io/kroki/setup/http-clients

This endpoint allows you to generate a diagram by uploading a file containing the diagram's source code using HTTPie, specifying the content type.

```APIDOC
## POST /<diagram_type>/<output_format> (from file with HTTPie)

### Description
Generates a diagram by piping the file content to the request.

### Method
POST

### Endpoint
`https://kroki.io/<diagram_type>/<output_format>`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of diagram to generate (e.g., 'erd').
- **output_format** (string) - Required - The desired output format for the diagram (e.g., 'svg').

#### Headers
- **Content-Type** (string) - Required - The MIME type of the file content (e.g., 'text/plain').

### Request Example
```bash
cat project.erd | http https://kroki.io/erd/svg Content-Type:text/plain
```

### Response
#### Success Response (200)
- **image_data** (string) - The generated diagram in the specified output format.
```

--------------------------------

### Adjust Diagram Conversion Timeout

Source: https://docs.kroki.io/kroki/setup/configuration

Sets the maximum time Kroki will wait for a Java library to convert a diagram. The default is 20 seconds. Similar to command timeouts, durations can be specified with various time units.

```shell
KROKI_CONVERT_TIMEOUT=10s
```

```shell
KROKI_CONVERT_TIMEOUT=1m
```

```shell
KROKI_CONVERT_TIMEOUT=4000ms
```

--------------------------------

### Generate Diagram from File (cURL)

Source: https://docs.kroki.io/kroki/setup/http-clients

This endpoint allows you to generate a diagram by uploading a file containing the diagram's source code using cURL's `--data-binary` option.

```APIDOC
## POST /<diagram_type>/<output_format> (from file)

### Description
Generates a diagram by reading the source code from a local file.

### Method
POST

### Endpoint
`https://kroki.io/<diagram_type>/<output_format>`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of diagram to generate (e.g., 'erd').
- **output_format** (string) - Required - The desired output format for the diagram (e.g., 'svg').

#### Request Body
- **file_content** (file) - Required - The content of the file containing the diagram source code.

### Request Example
```bash
curl https://kroki.io/erd/svg --data-binary '@project.erd'
```

### Response
#### Success Response (200)
- **image_data** (string) - The generated diagram in the specified output format.
```

--------------------------------

### Send Graphviz Diagram with cURL (POST)

Source: https://docs.kroki.io/kroki/setup/http-clients

Demonstrates sending a Graphviz diagram to the Kroki API using cURL with a POST request. The diagram source is provided directly in the request body. The output format is SVG.

```bash
curl https://kroki.io/graphviz/svg --data-raw 'digraph G {Hello->World}'
```

--------------------------------

### Send Graphviz Diagram with HTTPie (POST)

Source: https://docs.kroki.io/kroki/setup/http-clients

Illustrates sending a Graphviz diagram to the Kroki API using HTTPie with a POST request. This method allows specifying diagram type, output format, and diagram source as separate parameters. The output format is SVG.

```bash
http https://kroki.io/ diagram_type='graphviz' output_format='svg' diagram_source='digraph G {Hello->World}'
```

--------------------------------

### POST /:diagram_type/:output_format (Plain Text Request)

Source: https://docs.kroki.io/kroki/setup/usage

Converts a diagram to a specific output format using a POST request with plain text content and output format in URL.

```APIDOC
## POST /:diagram_type/:output_format (Plain Text Request)

### Description
This endpoint converts a diagram to a specific output format using a POST request. The diagram source is sent as plain text in the request body, and the output format is specified in the URL. Diagram options can be passed via HTTP headers.

### Method
POST

### Endpoint
`/:diagram_type/:output_format`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of the diagram (e.g., `graphviz`).
- **output_format** (string) - Required - The desired output format (e.g., `svg`).

#### Headers
- **Content-Type** (string) - Required - Must be `text/plain`.
- **Kroki-Diagram-Options-Key** (string) - Optional - Diagram specific option key.

### Request Example
```http
POST /graphviz/svg
Content-Type: text/plain
Kroki-Diagram-Options-Key: value

digraph G {
  Hello->World
}
```

### Response
#### Success Response (200)
Returns the generated image in the specified output format.

#### Response Example
```svg
<svg ...>...</svg>
```
```

--------------------------------

### Generate Diagram with HTTPie (POST)

Source: https://docs.kroki.io/kroki/setup/http-clients

This endpoint allows you to generate a diagram by sending the diagram source code as a field in the JSON request body. You specify the diagram type and output format in the URL.

```APIDOC
## POST /<diagram_type>/<output_format> (JSON body)

### Description
Generates a diagram by sending diagram details as a JSON object.

### Method
POST

### Endpoint
`https://kroki.io/<diagram_type>/<output_format>`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of diagram to generate (e.g., 'graphviz', 'erd').
- **output_format** (string) - Required - The desired output format for the diagram (e.g., 'svg', 'png').

#### Request Body
- **diagram_type** (string) - Required - The type of diagram (e.g., 'graphviz').
- **output_format** (string) - Required - The desired output format (e.g., 'svg').
- **diagram_source** (string) - Required - The source code of the diagram.

### Request Example
```bash
http https://kroki.io/ graphviz output_format='svg' diagram_source='digraph G {Hello->World}'
```

### Response
#### Success Response (200)
- **image_data** (string) - The generated diagram in the specified output format.
```

--------------------------------

### Send ERD File with HTTPie (POST)

Source: https://docs.kroki.io/kroki/setup/http-clients

Illustrates sending an Entity Relationship Diagram (ERD) from a file to the Kroki API using HTTPie with a POST request. The diagram content is piped from `cat` and the Content-Type is specified.

```bash
cat project.erd | http https://kroki.io/erd/svg Content-Type:text/plain
```

--------------------------------

### POST / (JSON Request)

Source: https://docs.kroki.io/kroki/setup/usage

Converts a diagram to a specified output format using a POST request with a JSON body.

```APIDOC
## POST / (JSON Request)

### Description
This endpoint converts a diagram to a specified output format using a POST request. The diagram source, type, and output format are provided in a JSON request body. Diagram options can also be included in the JSON body.

### Method
POST

### Endpoint
`/

### Parameters
#### Request Body
- **diagram_source** (string) - Required - The plain text source of the diagram.
- **diagram_type** (string) - Required - The type of the diagram (e.g., `graphviz`).
- **output_format** (string) - Optional - The desired output format (e.g., `svg`). Defaults to SVG if not specified.
- **diagram_options** (object) - Optional - An object containing key-value pairs for diagram specific options.
  - **key** (string) - Optional - Diagram specific option key.
  - **value** (string) - Optional - Diagram specific option value.

### Request Example
```json
{
  "diagram_source": "digraph G {Hello->World}",
  "diagram_type": "graphviz",
  "output_format": "svg",
  "diagram_options": {
    "key": "value"
  }
}
```

### Response
#### Success Response (200)
Returns the generated image in the specified output format.

#### Response Example
```svg
<svg ...>...</svg>
```
```

--------------------------------

### Svgbob API

Source: https://docs.kroki.io/kroki/setup/diagram-options

Generate diagrams using Svgbob. Customize background, font, colors, scale, and stroke width.

```APIDOC
## GET /websites/kroki_io_kroki/svgbob

### Description
Generates a diagram using Svgbob. This endpoint allows extensive customization of the diagram's appearance, including background color, font family and size, fill color, and scaling options.

### Method
GET

### Endpoint
/websites/kroki_io_kroki/svgbob

### Parameters
#### Query Parameters
- **background** (any) - Optional - Backdrop background color. Defaults to `white`.
- **font-family** (any) - Optional - Font family for text. Defaults to `arial`.
- **font-size** (integer) - Optional - Font size for text. Defaults to `14`.
- **fill-color** (any) - Optional - Fill color for solid shapes. Defaults to `black`.
- **scale** (any) - Optional - Scale factor for the entire SVG. Defaults to `1`.
- **stroke-width** (any) - Optional - Stroke width for all lines. Defaults to `2`.

### Request Example
```
GET /websites/kroki_io_kroki/svgbob?background=lightblue&font-size=16&scale=1.5
```

### Response
#### Success Response (200)
- **diagram** (string) - The generated SVG diagram.
```

--------------------------------

### Structurizr API

Source: https://docs.kroki.io/kroki/setup/diagram-options

Generate diagrams using the Structurizr format. You can specify a view key and the desired output format.

```APIDOC
## GET /websites/kroki_io_kroki/structurizr

### Description
Generates a diagram from Structurizr code. You can specify a view key to select a specific view within the workspace and choose the output format.

### Method
GET

### Endpoint
/websites/kroki_io_kroki/structurizr

### Parameters
#### Query Parameters
- **view-key** (string) - Optional - Key of the view (if the workspace contains more than one view).
- **output** (string) - Optional - Select the output format for the specified view. Allowable values: `diagram`, `legend`.

### Request Example
```
GET /websites/kroki_io_kroki/structurizr?view-key=my-view&output=diagram
```

### Response
#### Success Response (200)
- **diagram** (string) - The generated diagram in the specified format.
```

--------------------------------

### POST /:diagram_type (Plain Text Request)

Source: https://docs.kroki.io/kroki/setup/usage

Converts a diagram to a specified output format using a POST request with plain text content.

```APIDOC
## POST /:diagram_type (Plain Text Request)

### Description
This endpoint converts a diagram to a specified output format using a POST request. The diagram source is sent as plain text in the request body. The output format can be specified via the `Accept` header or in the URL. Diagram options can be passed via HTTP headers.

### Method
POST

### Endpoint
`/:diagram_type`

### Parameters
#### Headers
- **Accept** (string) - Optional - Specifies the desired output format (e.g., `image/svg+xml`). If not provided, the output format is determined by the URL or defaults to SVG.
- **Content-Type** (string) - Required - Must be `text/plain`.
- **Kroki-Diagram-Options-Key** (string) - Optional - Diagram specific option key.

### Request Example
```http
POST /graphviz
Accept: image/svg+xml
Content-Type: text/plain
Kroki-Diagram-Options-Key: value

digraph G {
  Hello->World
}
```

### Response
#### Success Response (200)
Returns the generated image in the specified output format.

#### Response Example
```svg
<svg ...>...</svg>
```
```

--------------------------------

### Generate Diagram with cURL (POST)

Source: https://docs.kroki.io/kroki/setup/http-clients

This endpoint allows you to generate a diagram by sending the diagram source code as raw data in the request body. You specify the diagram type and output format in the URL.

```APIDOC
## POST /<diagram_type>/<output_format>

### Description
Generates a diagram using the provided source code.

### Method
POST

### Endpoint
`https://kroki.io/<diagram_type>/<output_format>`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of diagram to generate (e.g., 'graphviz', 'erd').
- **output_format** (string) - Required - The desired output format for the diagram (e.g., 'svg', 'png').

#### Request Body
- **diagram_source** (string) - Required - The source code of the diagram.

### Request Example
```bash
curl https://kroki.io/graphviz/svg --data-raw 'digraph G {Hello->World}'
```

### Response
#### Success Response (200)
- **image_data** (string) - The generated diagram in the specified output format.
```

--------------------------------

### Encode String to Deflate + Base64 (Tcl)

Source: https://docs.kroki.io/kroki/setup/encode-diagram

Encodes a string stored in the `diagramSource` variable using zlib compression and then base64 encoding with URL-safe character replacements. It directly uses `zlib compress` and `binary encode base64`, followed by a `string map` for character translation.

```tcl
# assuming the diagram code is stored in the variable named `diagramSource`:
puts [string map {+ - / _} [binary encode base64 [zlib compress $diagramSource]]]
```

--------------------------------

### POST /:diagram_type/:output_format (JSON Request)

Source: https://docs.kroki.io/kroki/setup/usage

Converts a diagram to a specific output format using a POST request with a JSON body.

```APIDOC
## POST /:diagram_type/:output_format (JSON Request)

### Description
This endpoint converts a diagram to a specific output format using a POST request with a JSON body. The output format is specified in the URL, and the diagram source is included within the JSON payload. Diagram options can be included in the JSON body.

### Method
POST

### Endpoint
`/:diagram_type/:output_format`

### Parameters
#### Path Parameters
- **diagram_type** (string) - Required - The type of the diagram (e.g., `graphviz`).
- **output_format** (string) - Required - The desired output format (e.g., `svg`).

#### Request Body
- **diagram_source** (string) - Required - The plain text source of the diagram.
- **diagram_options** (object) - Optional - An object containing key-value pairs for diagram specific options.
  - **key** (string) - Optional - Diagram specific option key.
  - **value** (string) - Optional - Diagram specific option value.

### Request Example
```json
POST /graphviz/svg
{
  "diagram_source": "digraph G {Hello->World}",
  "diagram_options": {
    "key": "value"
  }
}
```

### Response
#### Success Response (200)
Returns the generated image in the specified output format.

#### Response Example
```svg
<svg ...>...</svg>
```
```

--------------------------------

### Encode Diagram with Python

Source: https://docs.kroki.io/kroki/setup/encode-diagram

Encodes diagram input from standard input using zlib compression and URL-safe base64 encoding in Python. It reads the diagram source from stdin, compresses it with zlib, and then encodes the result using base64.urlsafe_b64encode.

```python
import sys;
import base64;
import zlib;

print(base64.urlsafe_b64encode(zlib.compress(sys.stdin.read(), 9)))

```

--------------------------------

### Encode String to Deflate + Base64 (Go)

Source: https://docs.kroki.io/kroki/setup/encode-diagram

Encodes a given string into a Deflate compressed and URL-safe Base64 encoded string. It uses Go's standard library for zlib compression and base64 encoding. The function handles potential errors during writer creation, compression, and closing.

```go
package main

import (
	"bytes"
	"compress/zlib"
	"encoding/base64"

	"github.com/pkg/errors"
)

// Encode takes a string and returns an encoded string in deflate + base64 format
func Encode(input string) (string, error) {
	var buffer bytes.Buffer
	writer, err := zlib.NewWriterLevel(&buffer, 9)
	if err != nil {
		return "", errors.Wrap(err, "fail to create the writer")
	}
	_, err = writer.Write([]byte(input))
	writer.Close()
	if err != nil {
		return "", errors.Wrap(err, "fail to create the payload")
	}
	result := base64.URLEncoding.EncodeToString(buffer.Bytes())
	return result, nil
}
```

--------------------------------

### Encode Diagram with Kotlin

Source: https://docs.kroki.io/kroki/setup/encode-diagram

Encodes a given diagram source string into a compressed and URL-safe base64 encoded string in Kotlin. It uses `java.util.zip.Deflater` for compression and `java.util.Base64.getUrlEncoder()` for URL-safe base64 encoding. The compression level is set to best compression.

```kotlin
package main

import java.util.Base64
import java.util.zip.Deflater

object Encode {

  fun encode(decoded: String): String = 
    String(Base64.getUrlEncoder().encode(compress(decoded.toByteArray())), Charsets.UTF_8)

  private fun compress(source: ByteArray): ByteArray {
    val deflater = Deflater()
    deflater.setInput(source)
    deflater.finish()
    val bytesCompressed = ByteArray(Short.MAX_VALUE.toInt())
    val numberOfBytesAfterCompression = deflater.deflate(bytesCompressed)
    val returnValues = ByteArray(numberOfBytesAfterCompression)
    System.arraycopy(bytesCompressed, 0, returnValues, 0, numberOfBytesAfterCompression)
    return returnValues
  }
}

```

--------------------------------

### Encode Diagram with Java

Source: https://docs.kroki.io/kroki/setup/encode-diagram

Encodes a given diagram source string into a compressed and URL-safe base64 encoded byte array in Java. It uses `java.util.zip.Deflater` for compression and `java.util.Base64.getUrlEncoder()` for URL-safe base64 encoding. The compression level is set to `Deflater.BEST_COMPRESSION`.

```java
package main;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Base64;
import java.util.zip.Deflater;

public class Encode {

  public static byte[] encode(String decoded) throws IOException {
    return Base64.getUrlEncoder().encode(compress(decoded.getBytes()));
  }

  private static byte[] compress(byte[] source) throws IOException {
    Deflater deflater = new Deflater(Deflater.BEST_COMPRESSION);
    deflater.setInput(source);
    deflater.finish();

    byte[] buffer = new byte[2048];
    int compressedLength = deflater.deflate(buffer);
    byte[] result = new byte[compressedLength];
    System.arraycopy(buffer, 0, result, 0, compressedLength);
    return result;
  }
}

```

--------------------------------

### Encode String to Deflate + Base64 (C#)

Source: https://docs.kroki.io/kroki/setup/encode-diagram

Encodes a byte array representing diagram data into a Deflate compressed and URL-safe Base64 encoded string. It includes a `Deflate` method that handles compression, with special considerations for .NET versions and ZLIB header/trailer requirements. The `Main` method demonstrates its usage.

```csharp
using System;
using System.IO;
using System.IO.Compression;
using System.Text;

class Program
{
    static byte[] Deflate(byte[] data, CompressionLevel? level = null)
    {
        using (var memStream = new MemoryStream())
        {
#if NET6_0_OR_GREATER
            using(ZLibStream zlibStream = level.HasValue ? new(memStream, level.Value, true) : new(memStream, CompressionMode.Compress, true))
            {
                zlibStream.Write(data);
            }
#else

            // Reference: https://yal.cc/cs-deflatestream-zlib/#code

            // write header:
            memStream.WriteByte(0x78);
            memStream.WriteByte(level switch
            {
                CompressionLevel.NoCompression or CompressionLevel.Fastest => 0x01,
                CompressionLevel.Optimal => 0x0A,
                _ => 0x9C,
            });

            // write compressed data (with Deflate headers):
            using (DeflateStream dflStream = level.HasValue ? new(memStream, level.Value, true) : new(memStream, CompressionMode.Compress, true))
            {
                dflStream.Write(data, 0, data.Length);
            }

            // compute Adler-32:
            uint a1 = 1, a2 = 0;
            foreach (byte b in data)
            {
                a1 = (a1 + b) % 65521;
                a2 = (a2 + a1) % 65521;
            }

            memStream.WriteByte((byte)(a2 >> 8));
            memStream.WriteByte((byte)a2);
            memStream.WriteByte((byte)(a1 >> 8));
            memStream.WriteByte((byte)a1);

#endif

            return memStream.ToArray();
        }

        
    }

    public static void Main(string[] args)
    {
        var compressedBytes = Deflate(Encoding.UTF8.GetBytes("digraph G {Hello->World}"));
#if NET9_0_OR_GREATER
        // You can use this in previous version of .NET  with Microsoft.Bcl.Memory package
        var encodedOutput = System.Buffers.Text.Base64Url.EncodeToString(compressedBytes);
#else
        var encodedOutput = Convert.ToBase64String(compressedBytes).Replace('+', '-').Replace('/', '_');
#endif
        Console.WriteLine($"https://kroki.io/graphviz/svg/{encodedOutput}");
    }
}
```
Tokens:
Raw