Is Fliq really free right now?

Yes. During the public beta Fliq is free — 100,000 executions per day, no credit card. Paid plans (pay-as-you-go and enterprise) come later, and beta users get early-adopter terms.

How does billing work with retries?

Each execution attempt — including retries — is one unit. If a job fails and retries 3 times before succeeding, that's 4 attempts. During the beta you get 100,000 free per day, so even aggressive retry policies are fine.

How fast do jobs fire?

Jobs fire at the time you schedule them. The scheduler polls continuously and claims due jobs immediately, so a busy moment or a restarted worker doesn't mean a missed run. We're not quoting a latency SLA we haven't measured yet — watch the live status page for real numbers.

What happens if my endpoint is down?

Fliq retries with exponential backoff up to your configured limit. You see every attempt and its outcome — HTTP status code, response snippet, duration — in the dashboard and via the API.

Can AI agents use it?

Yes. Fliq ships an MCP server, so agents (Claude, Cursor, your own) can create, inspect, and cancel scheduled jobs as tool calls — a durable way for an agent to run on a schedule and pick work back up.

Do I need to change my codebase?

No. Fliq calls your existing HTTP endpoints. If it accepts a webhook today, it works with Fliq today — no SDK required, no agent to install. Authenticate calls however you already do.

The backend (Go) and this frontend are open source on GitHub. It's Postgres-native — no Redis or Kafka — so you'll be able to self-host the whole thing.

Free during public beta — 100,000 executions/day

Schedule any HTTP request.
Fliq runs it on time.

Cron jobs and scheduled webhooks without running infrastructure. Automatic retries, crash recovery, and a full per-execution history — in one API call. Built for backend teams and the AI agents they ship.

Start free →See how it works

Checking statusFree during public beta · 100k executions/day · no card

schedulerdemo--:--:-- UTC

POST

/v1/billing/charge

0 0 1 * * · Monthly billing

in 2s

POST

/v1/emails/digest

0 8 * * * · Daily digest

in 4s

GET

/health/partner

*/5 * * * * · Partner healthcheck

in 1s

POST

/v1/webhooks/sync

0 * * * * · Inventory sync

in 6s

4 schedules active3 executions · 0 lost

Scheduling is a solved problem. You shouldn't re-solve it.

The trap

Your app needs things to happen later — a reminder, a charge, a webhook, a sync. So you reach for cron on a server.

But that crontab has no retries, no history, and no idea a run failed. When the box restarts, the jobs just stop.

So you bolt on a queue, a worker, a heartbeat, a dead-letter table… and now you maintain a scheduler instead of your product.

With Fliq

One API. Any schedule. Zero ops.

✓

One API call schedules any HTTP request — once or on a cron

✓

Automatic retries with backoff — every attempt recorded

✓

Crash recovery built in — no run silently disappears

DIY cron + worker

Fliq

Setup

Cron box + queue + worker + retry code

One POST request

Retry logic

Write and tune it yourself

Built-in, configurable backoff

Crash recovery

Build a heartbeat + recovery system

Automatic reaper, included

Execution history

Build your own log table

Every attempt, queryable

When the box dies

Jobs silently stop firing

Stateless API + recovered jobs

Ops burden

High — you own the infra

Zero — it's a hosted API

Comparing a specific tool? See Fliq vs EasyCron, QStash, cron-job.org & more →

How it works

From one request to a recorded execution — no infrastructure in between.

Schedule

POST a target URL, method, body, and a fire time — a one-off ISO timestamp or a cron expression. One call, or use the dashboard.

Fire & retry

Fliq calls your endpoint on time. If it fails, it retries with backoff up to your limit. A reaper reschedules anything a crashed worker dropped.

Inspect

Every attempt is recorded — status code, duration, response. Query the full history by API or browse it in the dashboard.

See it run

Schedule a job and watch it fire, retry, and record — it's a demo, not live.

sandboxinteractive demo

schedule

make it fail

POST

https://api.myapp.com/welcome

one-off · fires once

not scheduled

Scheduled

Called

Retried

Done

execution history0 attempts

No executions yet — schedule the job to fire one.

Illustrative only — no request leaves your browser.

Everything a scheduler should do — and nothing to run

No queue to manage, no worker to deploy, no retry code to maintain.

One API Call

POST a URL and a fire time. That's it — no queue to configure, no worker to deploy, no infrastructure to babysit.

schedule a job

POST https://api.fliq.sh/jobs

Content-Type: application/json

{

"url": "https://yourapi.com/send-invoice",

"scheduled_at": "2026-03-05T09:00:00Z",

"max_retries": 3

}

Smart Retries

Exponential backoff, configurable max attempts. Failed jobs retry automatically — every attempt is recorded.

Full Observability

Every attempt logged: HTTP status, duration, error, worker. Search and filter your execution history.

Fires on schedule

Jobs fire at the time you set — the scheduler polls continuously, so a missed tick never means a missed job.

Durable by Design

Jobs and their execution history live in Postgres — the single source of truth. TLS 1.2+ in transit.

Cron + One-time

Any schedule: once, hourly, daily, monthly — standard cron syntax or ISO 8601 timestamps.

Quickstart

From idea to scheduled in 30 seconds

That's it. No queue to manage, no worker to scale, no infrastructure to babysit.

✓ Works with any HTTP endpoint
✓ JSON response with job ID instantly
✓ Cancel or update anytime before fire time

POST https://api.fliq.sh/jobs
Authorization: Bearer <your-token>
Content-Type: application/json

{
  "url": "https://yourapp.com/api/charge",
  "http_method": "POST",
  "scheduled_at": "2026-04-01T00:00:00Z",
  "max_retries": 3
}

const res = await fetch("https://api.fliq.sh/jobs", {
  method: "POST",
  headers: {
    "Authorization": "Bearer <your-token>",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    url: "https://yourapp.com/api/charge",
    http_method: "POST",
    scheduled_at: "2026-04-01T00:00:00Z",
    max_retries: 3,
  }),
});
const job = await res.json();
console.log(job.id); // job created

import httpx

res = httpx.post(
    "https://api.fliq.sh/jobs",
    headers={"Authorization": "Bearer <your-token>"},
    json={
        "url": "https://yourapp.com/api/charge",
        "http_method": "POST",
        "scheduled_at": "2026-04-01T00:00:00Z",
        "max_retries": 3,
    },
)
job = res.json()
print(job["id"])  # job created

curl -X POST https://api.fliq.sh/jobs \
  -H "Authorization: Bearer <your-token>" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://yourapp.com/api/charge",
    "http_method": "POST",
    "scheduled_at": "2026-04-01T00:00:00Z",
    "max_retries": 3
  }'

Outbound rate limiting

Call rate-limited APIs without the 429s

When you fire thousands of requests at Stripe, Shopify, or any third-party API, you get throttled, retries pile up, and ordering falls apart. A Fliq buffer is an ordered stream that delivers your requests to one endpoint at a rate you set — in order, with automatic retries, no Redis to run.

Stay under the limit

Set a rate — requests per second — and Fliq paces delivery to match. No more hammering Stripe, Shopify, or any partner API into a wall of 429s.

In submission order

A buffer delivers items in the order you pushed them, one at a time. A failed item retries in place — a later item never overtakes one that's still retrying.

Nothing to run

No Redis, no rate-limiter service, no token-bucket code to maintain. Push items and forget them — it's Postgres-native, like the rest of Fliq.

Start free →Read the buffer docs →

bufferinteractive demo

your requests

empty — send a burst

4/s

→

your API

api.stripe.com

200 OK

rate4 req/s

waiting

delivered

429 errors

What people build with Fliq

One-time jobs or recurring schedules — the API is identical.

One-time executions

Something happens in your app → trigger one action at a precise moment

✉️

Welcome email 60s after signup

Don't flood the inbox on registration. Fire exactly 1 minute later.

⏰

Trial expiry warning 24h before

Remind users before the deadline, not after they've already churned.

🔗

Webhook delivery to a partner API

Trigger partner integrations at the exact moment an event occurs.

💳

Charge a card at contract start date

Schedule the billing call months in advance — fire on the dot.

Recurring / Cron

Set it once, run it forever — at any interval

📦

Monthly subscription billing

Like Netflix — charge every 30 days, per customer, automatically.

🔄

Hourly data sync from a third-party API

Keep your data fresh without managing a background worker.

📧

Daily digest email to all active users

Send at 8 AM in each user's timezone with a single cron expression.

🏥

Every-5-minute health check

Ping external partners and alert if they go down.

Featured · AI agents

The execution layer your AI agents are missing

The same reliable scheduler backend teams use is exactly what autonomous agents need — a durable, observable way to run on a schedule and pick work back up.

Agents need to wake themselves up

A script ends when it returns. An agent has to run again tomorrow at 9am, or every 15 minutes. Fliq is the durable timer that calls your agent back.

Schedule in natural language

Fliq ships an MCP server. Point Claude, Cursor, or your own agent at it and it can create, inspect, pause, and cancel jobs as tool calls — no glue code.

Retries and history, so runs don't vanish

Every agent invocation is an HTTP call with automatic retries and a recorded outcome. When a 3am run fails, you see the attempt — not silence.

Read the MCP & agent docs →

// Schedule a welcome email in one call

POST

{ "url": "https://api.myapp.com/emails/welcome",

"scheduled_at": "2026-03-02T10:00:00Z" }

Reliability you can watch, not just read about

We won't quote you an SLA we can't prove yet. Here's the live status of the production API instead.

Checking status·Full status & uptime →

At-least-once delivery

Workers claim each job with FOR UPDATE SKIP LOCKED, so two workers never run it at once. A crashed or failed run is retried — delivery is at-least-once, so send an idempotency key and your endpoint stays safe.

Automatic crash recovery

Running workers heartbeat every few seconds. A reaper detects a worker that died mid-job and reschedules the work — no stuck jobs, no manual intervention.

Every attempt recorded

Each fire and each retry is written to the database before and after it runs: status code, duration, response. Query the full history by API or in the dashboard.

Built in the open

No magic numbers. Just the actual system.

Fliq is a young, beta product — so instead of inventing SLAs and customer logos, here's how it really works and where the code lives.

Star on GitHub

Postgres-native

Postgres-native — no Redis, no Kafka, no queue to operate.

At-least-once

Each job is claimed by one worker at a time via FOR UPDATE SKIP LOCKED. If a worker crashes mid-run the job is retried, so delivery is at-least-once — use an idempotency key on your endpoint.

Crash recovery

Workers heartbeat while running; a reaper detects crashed workers and reschedules their jobs automatically.

Full history

Full per-execution history: every fire, every retry, every response code, queryable via API and dashboard.

Self-hosted & enterprise

Run Fliq on your own infrastructure.

Fliq is Postgres-native and open source — so the whole stack can run on your Kubernetes cluster, your cloud account, or air-gapped on-prem. Same API, full control. Self-hosted and enterprise plans land after the beta.

Talk to us →

✓

Deploy on your own metal or any cloud

✓

No data leaves your infrastructure

✓

A dedicated support channel and SLA

✓

SSO / SAML integration

✓

Custom data retention policies

Free during beta

100,000 credits per day. No credit card required. Paid plans coming soon.

Beta

Free

100k credits / day · no credit card required

Growth

$1 / 100k

Coming soon

Enterprise

Custom

Coming soon

See full pricing →

Schedule any HTTP request.Fliq runs it on time.

Scheduling is a solved problem. You shouldn't re-solve it.

How it works

Schedule

Fire & retry

Inspect

See it run

Everything a scheduler should do — and nothing to run

Smart Retries

Full Observability

Fires on schedule

Durable by Design

Cron + One-time

From idea to scheduled in 30 seconds

Call rate-limited APIs without the 429s

Stay under the limit

In submission order

Nothing to run

What people build with Fliq

Welcome email 60s after signup

Trial expiry warning 24h before

Webhook delivery to a partner API

Charge a card at contract start date

Monthly subscription billing

Hourly data sync from a third-party API

Daily digest email to all active users

Every-5-minute health check

The execution layer your AI agents are missing

Agents need to wake themselves up

Schedule in natural language

Retries and history, so runs don't vanish

Reliability you can watch, not just read about

At-least-once delivery

Automatic crash recovery

Every attempt recorded

No magic numbers. Just the actual system.

Postgres-native

At-least-once

Crash recovery

Full history

Run Fliq on your own infrastructure.

Free during beta

Beta

Growth

Enterprise

Frequently asked questions

Scheduling is a solved problem. You shouldn't re-solve it.

How it works

Schedule

Fire & retry

Inspect

See it run

Everything a scheduler should do — and nothing to run

Smart Retries

Full Observability

Fires on schedule

Durable by Design

Cron + One-time

From idea to scheduled in 30 seconds

Call rate-limited APIs without the 429s

Stay under the limit

In submission order

Nothing to run

What people build with Fliq

Welcome email 60s after signup

Trial expiry warning 24h before

Webhook delivery to a partner API

Charge a card at contract start date

Monthly subscription billing

Hourly data sync from a third-party API

Daily digest email to all active users

Every-5-minute health check

The execution layer your AI agents are missing

Agents need to wake themselves up

Schedule in natural language

Retries and history, so runs don't vanish

Reliability you can watch, not just read about

At-least-once delivery

Automatic crash recovery

Every attempt recorded

Schedule any HTTP request.
Fliq runs it on time.