canonical: https://jentic.com/apis/getbioflow.com/getbioflow

# Getbioflow BioFlow API

The BioFlow API builds and publishes link-in-bio style pages made of content blocks. An agent creates a page, adds and removes blocks, updates the draft, and publishes it, then lists the contacts and files the pages have captured and reads an analytics summary over a chosen number of days. It also manages webhook endpoints end to end, listing deliveries, resending or replaying failed ones, sending a test event, and rotating the signing secret. Responses are JSON with RFC 9457 problem details on errors, and authentication is an API key sent as a bearer token or in the x-api-key header.

## For AI agents

Build link-in-bio style pages from blocks and publish them, list captured contacts and files, read an analytics summary, and manage webhook endpoints with delivery replay. Authenticates with an API key as a bearer token or in the x-api-key header.

## Scope

Does not handle payments, email sending, or domain hosting. Use for building and publishing bio pages and managing their webhooks only.

## Capabilities

- Create a page, add content blocks to it, and publish it
- Update a page draft and remove individual blocks
- List the contacts and files captured through the pages
- Read an analytics summary over a chosen number of days
- Register webhook endpoints and send a test event
- Replay or resend failed webhook deliveries
- Rotate a webhook endpoint's signing secret

## Use cases

### Agent-Built Bio Pages

An AI agent that assembles a link-in-bio or landing page can call the BioFlow API through Jentic to create the page, add a block for each link or section, and publish it. The agent builds and ships the page without the developer wiring the bearer or x-api-key auth or the page and block paths by hand. Jentic returns the matching operation and its input schema so the agent edits the page inline.

Example prompt: Create a page, add a block for each supplied link, and publish the page once all blocks are added

### Contact and Analytics Reporting

A dashboard can report how pages are performing by pulling the contacts they captured and an analytics summary for a chosen window. BioFlow lists captured contacts with cursor paging and returns an analytics summary over a set number of days, so a workflow can show leads collected and traffic trends together.

Example prompt: Pull the analytics summary for the last 30 days and list the contacts captured in that window

### Webhook Delivery Management

A service that reacts to page events can register a webhook endpoint, confirm it with a test event, and recover from outages by replaying or resending failed deliveries. BioFlow manages webhook endpoints, lists their deliveries filtered by status, resends a single delivery, replays all failed ones, and rotates the signing secret.

Example prompt: Register a webhook endpoint, send a test event to confirm it, and replay any deliveries that previously failed

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| POST | `/v1/pages` | Create a page |
| POST | `/v1/pages/{page_id}/blocks` | Add a block to a page |
| POST | `/v1/pages/{page_id}/publish` | Publish a page |
| GET | `/v1/contacts` | List captured contacts |
| GET | `/v1/analytics/summary` | Get an analytics summary |
| POST | `/v1/webhook-endpoints` | Create a webhook endpoint |
| POST | `/v1/webhook-endpoints/{endpoint_id}/replay` | Replay failed deliveries |

## Key resources

- **Pages** — Create, read, update, delete, and publish pages built from content blocks.
- **Blocks** — Add a block to a page or remove a block from it.
- **Contacts and Files** — List the contacts and files captured through the pages.
- **Analytics and Usage** — Read an analytics summary over a date range and the current API usage.
- **Webhook Endpoints** — Manage endpoints, list and resend deliveries, replay failures, and rotate the signing secret.

## 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:** 79 / 100
- **Maturity:** AI-Ready
- **Dimensions:**
  - Foundational Compliance: 99 / 100
  - Developer Experience & Jentic Compatibility: 73 / 100
  - AI-Readiness & Agent Experience: 78 / 100
  - Agent Usability: 94 / 100
  - Security: 55 / 100
  - AI Discoverability: 90 / 100
- **View full report:** https://jentic.com/apis/getbioflow.com/getbioflow/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 BioFlow by hand means supplying its API key as a bearer token or x-api-key header, threading page and block ids through each path, and handling RFC 9457 problem details on errors. Through Jentic you install once, import BioFlow from the API Directory, store the key once, and your agent calls it.
- **Permission scoping:** BioFlow puts the page id and webhook endpoint id in the URL path, so a rule can pin your agent to one page or one endpoint and the operations you pick. You choose which operations it may call, so page deletion and secret rotation are not included unless you add them.
- **Credential handling:** Your BioFlow API 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 'create a page' or 'replay failed webhook deliveries', and Jentic returns the matching BioFlow operation with its input schema so the agent calls the right endpoint directly.

## Related APIs

- **Cosmic API** — Headless CMS to create, update, and publish content objects.
- **Flotiq User API** — Reads and writes structured content objects, media, and tags.
- **Agility CMS REST API** — Manages pages, lists, sitemaps, and URL redirects for a full site.

## FAQ

### What authentication does the BioFlow API use?

The BioFlow API authenticates with an API key, supplied either as a bearer token in the Authorization header or in the x-api-key header, per its OpenAPI spec. Through Jentic the key is stored once, encrypted, by your own Jentic One instance and injected at call time, so it never reaches the agent's prompt or logs.

### Is there a BioFlow MCP server?

You don't need an MCP server to give your agent the BioFlow API. Jentic connects it directly from the API Directory: import it, store your key once, and your agent can build and publish pages straight away.

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

Yes. BioFlow puts the page id and the webhook endpoint id in the URL path, so a rule can bound your agent to one page or one endpoint and the operations you pick. Allow it to create pages and add blocks but leave page deletion and secret rotation out unless you add them, and every call it makes is logged.

### Can I publish a page with the BioFlow API?

Yes. An agent creates a page, adds a content block for each section, and then calls the publish operation to make the page live, updating the draft with further edits before publishing again if needed.

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

The OpenAPI spec exposes a usage operation that reports your current API usage but does not publish a fixed numeric ceiling. Check the BioFlow documentation for the current limits on your plan.

### How do I create and publish a page with the BioFlow API through Jentic?

Search Jentic for an intent like 'create and publish a page' and it returns the BioFlow page operations with their input schemas, so your agent creates the page, adds blocks, and publishes it. To run it on your own infrastructure, install Jentic One from its GitHub repo.