FlowynBETA
LoginSign up
For humans and AI agents

Build fast.Run reliably.

Infrastructure for applications and AI agents. Process files, execute durable HTTP work, connect events, observe what ran, and configure behavior through one API.

Try the PlaygroundRead the quickstart
PDF received
test
quarterly-report.pdf
PDF · 18 pages · 4.2 MB
Accepted
Stored before any processing starts. Job job_parse_7ab2 was returned with HTTP 202.
Result
Waiting for the worker. Poll GET /v1/file-jobs/{id} until it finishes.
job
job_parse_7ab2
attempt
—
Build vs. Flowyn

The API call is easy. Everything around it is not.

Most applications end up rebuilding the same layer: somewhere to run slow work, something to retry it, and a record of what happened. Flowyn is that layer.

01

Document workers

Upload handling, conversion binaries, PDF tooling, parsers, output storage, and cleanup, running somewhere other than your web request.

02

Retry and delivery machinery

Backoff, idempotency keys, webhook signing, attempt logs, replay, and a way to recover after a receiver was down.

03

Queues and schedulers

Durable claims, leases, stale-worker recovery, delays, cron that survives deploys, and history of what actually ran.

You make one API call. Flowyn persists the operation, runs it on managed workers, retries within a finite policy, and keeps every attempt inspectable.

Five verbs. Each shown as a small result.

Each card is one Flowyn story: what went in, what Flowyn did, and the result you can read back.

01Explore
PDF received
test
quarterly-report.pdf
PDF · 18 pages · 4.2 MB
Accepted
Stored before any processing starts. Job job_parse_7ab2 was returned with HTTP 202.
Result
Waiting for the worker. Poll GET /v1/file-jobs/{id} until it finishes.
job
job_parse_7ab2
attempt
—
Process

Documents & files

Upload → process → completed output

Conversion, split, and structural parsing, with the output linked to the file.

02Explore
Job stored
test
POSThttps://api.example.com/reports/generate
Queued
job
job_8f29a
policy
5 attempts · exp. backoff
timeout
10,000 ms
idempotency
sync-invoice-881
Attempts · append-only
The call is persisted before any worker runs it. Nothing has been sent yet.
Execute

Durable HTTP & schedules

HTTP call → retry → success

The call is stored, retried within a finite policy, and left with its attempt history. Schedules create the same jobs on cron.

03Explore
Event stored · 202
test
order.completed
evt_8e12c · signed · idempotency order-123
Stored
https://hooks.example.com/orders
Delivery attempts
Persisted before any endpoint is called. Your request already returned HTTP 202.
Connect

Reliable events & webhooks

Event → attempts → delivered

Stored first, signed, retried, and replayed without erasing the earlier attempts.

04Explore
Checking every 60s
test
GETapi.example.com/health
Healthy
last 16 checks · interval 60slatest 184 ms
12 consecutive passing checks. Flowyn requests the URL, records status and latency, and does not touch your API.
Observe

Monitors & issues

Check → incident → recovered

HTTP, heartbeat, and API checks record latency, failure, incident, and recovery.

05Explore
Context received
test
checkout_v2
Context
environment
production
user_id
usr_142
plan
pro
country
DE
Rules · same input, same path, every time
Rule 1environment is stagingpending
Rule 2plan is enterprisepending
Rollout25% by user_idpending
Configure

Flags & remote configuration

Context → evaluation → value and reason

The same context returns the same value, with the rule that chose it.

06Explore
Repeated failures stored
test
Events · destination hooks.example.com/orders
#1evt_8f1e · HTTP 500 Internal Server Error2m agoFailed
#2evt_8f20 · HTTP 500 Internal Server Error4m agoFailed
#3evt_8f21 · HTTP 500 Internal Server Error6m agoFailed
Each failed delivery stores the same error text. Investigating them one by one is the problem.
Observe

Issues & diagnostics

Failures → one issue → evidence

Repeated errors are grouped. Open the count, the latest example, and the evidence.

How it works

State transitions you can reason about.

Every operation moves through explicit states and keeps an append-only attempt history, so a failure is something you can inspect and act on.

Documents

PDF received
test
quarterly-report.pdf
PDF · 18 pages · 4.2 MB
Accepted
Stored before any processing starts. Job job_parse_7ab2 was returned with HTTP 202.
Result
Waiting for the worker. Poll GET /v1/file-jobs/{id} until it finishes.
job
job_parse_7ab2
attempt
—

Plain REST. A result an agent can read.

Bearer API key, JSON body, and an Idempotency-Key on every durable create. REST, OpenAPI, the repository SDK, the CLI, and stdio MCP all describe the same resources.

Delivery and execution are at-least-once, so receivers should deduplicate. Flowyn forwards an idempotency key on outbound calls to help.

REST API reference
POSThttps://api.flowyn.dev/v1/events202
curl -X POST https://api.flowyn.dev/v1/events \
  -H "Authorization: Bearer flw_test_••••" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: order-123-created" \
  -d '{
    "type": "order.created",
    "payload": {
      "order_id": "ord_123"
    }
  }'
Persisted before delivery
POSThttps://api.flowyn.dev/v1/jobs202
curl -X POST https://api.flowyn.dev/v1/jobs \
  -H "Authorization: Bearer flw_test_••••" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: sync-invoice-881" \
  -d '{
    "url": "https://api.example.com/sync",
    "method": "POST",
    "timeout_ms": 10000,
    "max_attempts": 5
  }'
Stored, then executed with retries
POSThttps://api.flowyn.dev/v1/schedules200
curl -X POST https://api.flowyn.dev/v1/schedules \
  -H "Authorization: Bearer flw_test_••••" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: nightly-report" \
  -d '{
    "name": "Nightly report",
    "cron": "0 2 * * *",
    "timezone": "Europe/Berlin",
    "method": "POST",
    "url": "https://api.example.com/reports/nightly"
  }'
Each occurrence creates a job
Infrastructure for software and AI agents

Deploy your agent anywhere. Flowyn keeps the record.

Flowyn is the infrastructure around your agent, not the intelligence inside it. Register an agent you run yourself, record its runs, send its traces, and ask a person to approve what matters. Any framework, plain REST.

Runs, traces, and steps. Record each run your agent performs and send its spans. Model calls and tool calls become steps with timing, status, and errors.

Model usage and cost. Input, output, and cached tokens, latency, and reported or estimated cost, by model, provider, or trace.

Human approvals. Your agent asks; a signed-in person approves or rejects; your runtime reads the decision and continues. Flowyn never pauses it.

Building with a coding agent? It can integrate Flowyn from llms.txt and the OpenAPI document. API keys stay server-side, and Flowyn reports facts; it does not operate your systems.

Explore Agent Infrastructure Agent quickstart

From account to first observable operation.

The same path works for every capability.

Use cases

Start with the problem you have.

Reliable webhooks
Stop losing webhooks when a receiver is down.
Document & PDF API
Convert, merge, split, and parse documents without running workers.
Scheduled HTTP requests
Cron for HTTP endpoints, with history of what actually ran.
Agent infrastructure
Runs, traces, model usage, and human approvals for agents you deploy.

Frequently asked questions

What is Flowyn?
Flowyn is API-first infrastructure for applications and AI agents. Five primitives cover the work around your code: Process (documents and files), Execute (durable HTTP jobs and schedules), Connect (events and webhooks), Observe (monitors, heartbeats, and issues), and Configure (keys and flags). Agent infrastructure builds on them to record the runs, traces, model usage, and human approvals of agents you deploy yourself.
What does Flowyn not do?
Flowyn records, verifies, evaluates, executes bounded HTTP work, and reports facts. It does not operate your systems, host or execute your agents, run model inference, or provide agent memory.
Why not build this myself?
You can. It usually means a queue, workers, retry and backoff logic, idempotency storage, webhook signing, replay tooling, stale-worker recovery, a scheduler, and conversion binaries, maintained in every application. Flowyn runs that layer so your code makes one API call.
Is delivery exactly once?
No. Webhook delivery and HTTP execution are at-least-once. Send an Idempotency-Key on create requests, and deduplicate in receivers using the stable id Flowyn sends with every attempt.
Is Flowyn a Zapier or Make alternative?
No. Flowyn is not a workflow canvas or no-code automation tool. It is infrastructure your own code calls through an API.
Does it work with AI agents?
Yes, two ways. Coding agents can integrate Flowyn from llms.txt and the OpenAPI document. Agents you build can report their runs, traces, model usage, and approval requests to Flowyn's agent endpoints, whatever framework they use.
Do I need to run workers?
No. File processing and outbound HTTP work run on Flowyn's managed workers.

Stop rebuilding the reliability layer.

Create a workspace, make your first call in the test environment, and inspect every attempt.

Start building Read the docs