Build Your Embedded Analytics Integration with the Yurbi API

If you're evaluating embedded analytics for your software, the question that matters after "does it look right?" is "how much work is the integration?" We've published the answer at developers.yurbi.com: a complete reference for the Yurbi embedded analytics API, guides for each common integration task, a Postman collection, and AI-ready files you can load into your coding assistant so it writes against real endpoints instead of guessing.

The short answer: a working embed takes two API calls, a sign-in that returns a session token and an iframe URL that uses it. Everything else a software vendor needs (provisioning tenants, isolating each customer's data, white-labeling, running reports from your own code) is documented step by step.

What's on the developer site

The Yurbi API is deliberately simple. Every endpoint is an HTTP POST that accepts and returns JSON, all endpoints live under one base path on your own Yurbi server, and there is one authentication model: sign in once, then pass the session token on every call.

The site has three parts:

  • Getting started. A Quickstart that gets you to a first successful call in a few minutes, plus how sessions and tokens work and the conventions and error codes shared by every endpoint.
  • Guides. Use-case walkthroughs written for software teams building Yurbi into their own product.
  • API reference. More than 80 endpoints, each with its parameters, a request body and a real example response. The Reference page has a built-in "Try it": enter your server's address and a token, and send any request live or copy it as cURL.

The integration path, step by step

Most embedded reporting integrations follow the same sequence. Each step below links to the guide that covers it.

1. Sign users in without a second login

You already authenticate users in your application, so they shouldn't have to sign in to reporting separately. Your server calls the sign-in endpoint, receives a session token, and uses it either to embed specific content or to drop the user straight into the full Yurbi interface. The Single Sign-On guide covers both options and how to keep sessions alive.

2. Provision each customer as a tenant

Serving many customers from one Yurbi instance comes down to a repeatable structure: one security group per tenant, one library folder scoped to that group, and users who belong to exactly one tenant. The Multi-tenant provisioning guide gives you the calls in order, so onboarding a new customer becomes part of your own signup flow rather than a manual admin task.

3. Isolate each tenant's data with row-level security

A single report should serve every customer while returning only the rows each one is entitled to. Yurbi does this with data tags and data security policies applied when the report runs, so the same restriction covers the interface, embeds, exports and scheduled email. The Row-level data security guide shows how to set it up and, just as important, how to verify it.

4. Embed dashboards and reports

With a token in hand, build an embed URL for a dashboard or report and place it in an iframe. You can pre-fill report prompts in the URL, too. The Embedding guide covers finding item IDs, prompts and session handling.

5. Run reports from your own code

Sometimes you want the data, not the visualization: to feed your own UI, a data export or another system. The Run reports from your app guide walks through finding a report, supplying prompt values and reading the rows and columns that come back.

6. Make it look like your product

Branding profiles control logos, colors, fonts, the login page and which features each audience sees, and they can be assigned per tenant group. See Branding and white-labeling and, for pixel-level control, Custom CSS.

7. Keep integration accounts working as security tightens

If your customers turn on two-factor authentication or password rules, the accounts your application signs in with should keep working. The Login security and two-factor guide explains how to flag those accounts as service accounts so automated sign-ins are never interrupted.

There's also a guide to building apps and reports through the API for teams that generate the reporting layer at provisioning time or migrate reports in from another tool.

Get running in minutes with Postman and OpenAPI

You don't need to write code to explore the API. On the API spec and tooling page you'll find:

  • A Postman collection with every documented endpoint as a ready-to-send request, grouped by area. Set your server address, run the sign-in request, and the collection captures the token for every other call.
  • An OpenAPI 3.1 spec you can import into Swagger UI or Insomnia, or use with a code generator to scaffold a typed client in your language.

Both are generated from the same source as the documentation, so they always match the published reference.

Let your AI coding assistant write the integration

This is the part we're most excited about. The developer site publishes two files written for AI models:

  • llms.txt, a compact index of the documentation.
  • llms-full.txt, the complete documentation, guides and endpoint reference in a single file.

Load llms-full.txt into Claude, ChatGPT, Copilot, Cursor or whichever assistant your team uses, and it can answer questions and write integration code against the real endpoints, parameters and response shapes. A few prompts to try:

  • "Using the Yurbi API documentation, write a Node.js function that signs a user in and returns an embed URL for dashboard 123. Cache the token on the server."
  • "Write a Python script that provisions a new tenant: create the security group, the library folder scoped to it, and a first user with an Agent role."
  • "Given the Yurbi API docs, how do I run a report with two prompts and return the rows as JSON?"

As with any generated code, review it, keep credentials on your server, and test against a non-production Yurbi instance before you ship.

Why this beats vibe-coding the whole reporting layer

We recently wrote about vibe-coded dashboards vs. embedded analytics: AI tools can build a working dashboard in an afternoon, but the long-term cost of customer-facing reporting is everything around that dashboard.

Using AI to write your integration with Yurbi is a different thing, and it's the approach we recommend:

  • Vibe-coding the reporting layer means AI generates the dashboards, queries, permissions and tenant isolation, and your team owns, tests and maintains all of it, along with every new report request that follows.
  • AI-assisted integration means AI writes the small amount of glue code between your application and Yurbi: sign-in, tenant provisioning, embed URLs. Yurbi supplies the report builder your customers use themselves, tenant isolation enforced at the query level, scheduling, exports, permissions and white-labeling.

The code you own stays small and well-defined, because it targets a documented API instead of reinventing a reporting product. That's also what makes AI assistance reliable here: the assistant is working from an accurate reference rather than inventing an architecture.

Built for software vendors who self-host

Yurbi runs on your own infrastructure, Linux, Docker or Windows, so your customers' data stays where it already lives and the API talks to your own server. That keeps the integration simple to reason about for your security reviews, and it means the documentation describes exactly what you'll deploy.

Start building

If there's a call you need that isn't documented yet, tell us what you're trying to accomplish. We're glad to help, and to add it to the docs if it fits.

Frequently asked questions

How long does it take to embed Yurbi in a SaaS application?

A basic embed takes two API calls: one to sign the user in and get a session token, and an iframe that uses that token. Most of the remaining work is provisioning tenants and setting up row-level security, which the developer guides walk through step by step.

Does the Yurbi API support multi-tenant embedded analytics?

Yes. The recommended structure is one security group and library folder per tenant, with data security policies that constrain every query to the tenant's own rows. The Multi-tenant provisioning guide lists the API calls to automate it.

Can I use AI coding assistants to build a Yurbi integration?

Yes. The developer site publishes llms.txt and llms-full.txt, which you can load into Claude, ChatGPT, Copilot or Cursor so the assistant writes code against the real endpoints. Review and test generated code before using it in production.

Is there a Postman collection or OpenAPI spec for the Yurbi API?

Yes. Both are available on the API spec and tooling page at developers.yurbi.com and are generated from the same source as the documentation.

How is AI-assisted integration different from vibe-coding dashboards?

Vibe-coding builds the reporting layer itself, which your team then maintains. AI-assisted integration only generates the glue code between your application and Yurbi, while Yurbi provides the report builder, tenant isolation, scheduling, exports and white-labeling.