canonical: https://jentic.com/apis/rombik.app/rombik

# Rombik App rombik API

The rombik API turns program source code into algorithm flowcharts drawn to the Ukrainian DSTU standard, using the same engine as the rombik website. It accepts code in languages such as Python, C++, Java, C#, Pascal, JavaScript, Go, and PHP, or rombik's own astJSON format, and exports to formats including DOCX, Visio, draw.io, SVG, PNG, PDF, and Excalidraw. A diagram can be a classic flowchart or a Nassi-Shneiderman structogram, rendered for the whole program, one function, or each function separately. A batch call renders many sources into one multi-page PDF or a ZIP, and a temporary link endpoint shares a result for one hour.

## For AI agents

Render source code as DSTU-style flowcharts or Nassi-Shneiderman diagrams in DOCX, SVG, PNG, PDF, or draw.io, singly or in batches, with rombik.

## Scope

Does not run or test code, host repositories, or draw free-form diagrams from markup. Use for rendering source code into flowcharts and structograms only.

## Capabilities

- Render a flowchart from source code passed as code or fetched from a raw GitHub or Gist url
- Choose the output format, including docx, visio, drawio, svg, png, pdf, excalidraw, and gif_anim
- Switch between a flow diagram and a Nassi-Shneiderman structogram with the mode field
- Render one named function with fn, or every function as a separate file in a ZIP with perFunc
- Batch-render up to 100 sources into a single multi-page PDF or a ZIP bundle
- Publish a rendered file to a temporary public link that expires after one hour
- Read the key's plan and monthly export usage with GET /me

## Use cases

### Coding agent that documents algorithms

A coding agent asked to document an algorithm can produce the diagram instead of describing it. Through Jentic it searches for 'flowchart from code', loads rombik's POST /render, and sends the function as code with lang set to python and format set to svg, while the X-API-Key value is added by the developer's own instance. The returned SVG drops straight into the project's docs.

Example prompt: Call POST /render with lang 'python', format 'svg', fn 'bsearch', and the module source as code, then save the returned file to docs/bsearch.svg

### Coursework flowcharts in DSTU format

Students in Ukraine often have to submit algorithm flowcharts drawn to DSTU conventions inside a Word report. POST /render with format docx splits tall diagrams into parts joined by connectors by default, and mode nsd produces a Nassi-Shneiderman structogram when the assignment asks for one instead of a flowchart.

Example prompt: Call POST /render with lang 'cpp', format 'docx', and the program source as code, and return the DOCX file

### Batch diagrams for a whole repository

Documenting many files at once is one call rather than many. POST `/render/batch` takes an items array of up to 100 entries, each with code or a url, and returns a single multi-page PDF when format is pdf or a ZIP with one file per item otherwise. With json=1 the response reports each item's result alongside the bundle.

Example prompt: Call POST `/render/batch` with format 'pdf' and items listing three raw.githubusercontent.com urls, then return the combined PDF

### Sharing a diagram in chat

Chat bots and email flows often cannot attach files directly. POST /r stores the bytes returned by /render and gives back a public link that lives for one hour, and GET `/r/{token}` serves it without a key, opening images and PDFs in the browser.

Example prompt: Call POST /render with format 'png', then call POST /r with the PNG bytes and name 'schema.png' and return the link to the user

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/render` | Render a flowchart from code |
| POST | `/render/batch` | Render many sources into one PDF or ZIP |
| GET | `/me` | Plan and monthly usage for the key |
| POST | `/r` | Create a one-hour public link to a file |
| GET | `/r/{token}` | Fetch a file by temporary link |
| GET | `/products` | List plans |
| GET | `/skill.md` | Agent skill file for the API |

## Key resources

- **Render** — Single-source rendering of code into a flowchart or structogram in the chosen format
- **Batch render** — Many sources rendered into one multi-page PDF or a ZIP bundle
- **Temporary links** — One-hour public links to rendered files
- **Account** — The key's plan and monthly export usage, the list of plans, and plan top-up
- **Sign in with rombik** — OAuth 2.0 authorization code with PKCE and OIDC userinfo for third-party apps

## AI readiness

This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.

- **Score:** 53 / 100
- **Maturity:** Foundational
- **Dimensions:**
  - Foundational Compliance: 99 / 100
  - Developer Experience & Jentic Compatibility: 62 / 100
  - AI-Readiness & Agent Experience: 27 / 100
  - Agent Usability: 94 / 100
  - Security: 70 / 100
  - AI Discoverability: 69 / 100
- **View full report:** https://jentic.com/apis/rombik.app/rombik/scorecard
- **How the score is calculated:** https://docs.jentic.com/reference/api-readiness-framework/overview/
- **More about the dimensions:** https://docs.jentic.com/reference/api-readiness-framework/specification/#dimensional-model-overview

### Score it yourself

Every API in the directory is allowlisted, so you can re-score it with no key required.

- **Score your own API:** https://jentic.com/scorecard.md
- **Scoring CLI agent skill:** https://github.com/jentic/jentic-api-scorecard/blob/main/skills/jentic-api-scorecard/SKILL.md

```sh
npx @jentic/api-scorecard-cli score <openapi-url>
```

## Why Jentic

- **Setup:** Wiring rombik by hand means getting an rk_ key onto a Pro plan, sending it in X-API-Key, handling 402 responses when the plan or monthly allowance runs out, and choosing between file and json=1 responses. Through Jentic you install once, import rombik from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** rombik takes the code, format, and options in the request body, so limit the agent to the operations it needs, such as single renders. You choose the operations it may call, so ones that spend money or allowance, like POST /topup or POST `/render/batch`, are not included unless you add them.
- **Credential handling:** Your rombik key is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
- **Discovery method:** Agents search Jentic by intent such as 'flowchart from code' or 'Nassi-Shneiderman diagram', and Jentic returns the matching rombik operation with its input schema, including the lang, format, and mode enums.

## Related APIs

- **Mermaid Chart** — Diagram documents written in Mermaid syntax
- **GitHub** — Source repositories whose files can feed rombik's url input
- **CloudConvert** — General file conversion between document and image formats

## FAQ

### What authentication does the rombik API use?

The rombik OpenAPI spec declares two schemes. ApiKeyAuth is an rk_ API key sent in the X-API-Key header, and the spec's description says the same key can also go in Authorization as a bearer; render, batch, account, and link-creation calls use it. OAuth2 is an authorization code flow with PKCE and OIDC for apps that let users sign in with rombik, and GET `/oauth/userinfo` requires its openid scope. Some routes, such as GET `/r/{token}`, GET /skill.md, and GET `/oauth/jwks`, declare no security at all.

### Which languages and output formats does rombik render?

The lang field accepts python, cpp, c, java, csharp, pascal, javascript, typescript, php, go, and rombik for its native astJSON tree. POST /render can export docx, visio, drawio, typst, excalidraw, svg, png, jpeg, webp, gif, gif_anim, html, pdf, json, or poster, and mode chooses between flow and nsd diagrams.

### What are the rate limits for the rombik API?

The OpenAPI spec does not state a request rate. It says rendering with a key needs the Pro plan and that each exported file counts against the plan's monthly allowance, returning 402 pro_required or 402 fair_use when those conditions are not met. GET /me shows the current plan and usage; see https://rombik.app/ for plan details.

### Is there a rombik MCP server?

You do not need an MCP server to give your agent rombik. Jentic connects it directly from the API Directory: import it, store your credential once, and your agent calls the render operations as it needs them without another server's tool definitions in its context.

### How do I render a flowchart through Jentic?

Search Jentic for 'generate a flowchart from code', load the POST /render operation, and send lang, format, and the source as code, or a url on an allowed host such as raw.githubusercontent.com. Add json=1 to get a JSON body with a content field instead of the raw file. To run it on your own infrastructure, install Jentic One from its GitHub repo.

### Can I limit what my agent is allowed to do with the rombik API?

Yes. Write a rule that allows only POST /render and GET /me, so the agent can draw diagrams and check remaining exports but cannot start a plan payment through POST /topup or run large batches, and every call it makes is logged.
