01
Versions you can roll back
Every push is kept as a version, so going back to a good one takes a click.
From code to running, in one click
Push your code.
We run it.
DagFlows runs your team's workflows and web scrapers straight from your repository, so nobody has to set up or look after a server.
Free plan. No card required.
Every team has jobs that must run on time. Reports, syncs, price checks, and scrapers. Today each one needs a server, a schedule, and someone awake when it breaks.
- Servers
You set up and patch a server just to run one script.
- Silent failures
A job fails at 2 a.m. and nobody notices until morning.
- Guesswork
Nobody is sure which version of the code is live.
How it works
Three steps from your repository to a running job.
-
Connect your repository
Sign in with GitHub and choose a repository, public or private.
-
Push your workflow or scraper
Commit your code the way you already do. There is nothing new to learn.
-
DagFlows builds, schedules, and retries it
Every push becomes a version that runs when you say, and tries again if it fails.
What you get
Everything a job needs after you push it.
02
Schedules and triggers
Run a job on a timetable, when a webhook arrives, or whenever you press Run.
03
Automatic retries
When a run fails, DagFlows tries again and shows you what went wrong.
04
Build and run history
See every build and every run, with its logs, timing, and result.
05
Team roles and groups
Organise work into projects and decide who can view or change each one.
06
Private GitHub repositories
Connect private repositories. Your code stays where it already lives.
In action
Watch the work happen.
What your team sees while DagFlows scrapes, builds, and runs. Nothing to refresh, nothing to guess.
Scrapers
Collect data from thousands of pages
Point a scraper at the pages you need. DagFlows works through them, tries again when a page fails, and counts every item it saves.
A scraper run, page by page. Example data.
Builds
Every push becomes a version
DagFlows clones your repository, builds it, and saves a version you can run again later. You can follow each step as it happens.
A build, from commit to version. Example data.
Runs
Many runs at once, in order
Runs start from a schedule, a webhook, or an event. Choose how many can run together, and the rest wait their turn.
Three at once, the rest queued. Example data.
For developers
Plain code in, a running job out.
Write steps in Python, TypeScript, or Go, and connect them. DagFlows checks the data passed between languages before a run starts.
Go
package main import df "github.com/dagflows/sdk-go" type Listing struct { URL string `json:"url"` Title string `json:"title"` Price float64 `json:"price"`} // Walks every results page and streams listings out as rowsfunc fetchListings(*df.Ctx, df.None) (df.Rows[Listing], error) { return func(yield func(Listing, error) bool) { for page := 1; page <= 1200; page++ { for _, item := range scrapePage(page) { if !yield(item, nil) { return } } } }, nil} func main() { wf := df.NewWorkflow("competitor_listings", df.WorkflowOptions{}) wf.Node(fetchListings, df.Root, df.NodeOptions{ Key: "fetch_listings", Execution: &df.Execution{Machine: "gp-4", TimeoutSecs: 1800}, }) df.Main()}Each step in the language that suits it.
A Go scraper collects listings, a TypeScript step converts prices, and a Python step sends the report. DagFlows checks the data passed between them before the run starts.
Example run
fetch_listings GO 9,480 rows
enrich_prices TS 9,480 rows
weekly_report PY 0.8 s
-
Use the languages you already know
Toolkits for Python, Node.js, and Go. Mix them in one pipeline, and DagFlows checks the data passed between steps.
-
Your code stays in your repository
There is no special format to move into, and nothing to rewrite if you ever leave.
-
See every run, every log
Each run shows what started it, which version ran, how long it took, and what it printed.
Built to grow
Start with one job. Grow without changing a thing.
Runs this hour42 Servers you manage0 Live
No servers
We run the machines. You write the code.
Every run starts on DagFlows. There is nothing to set up, patch, or keep awake, however busy the day gets.
Credits used1,488 Waiting, 0 credits
Pay for what you use
Pay while your code runs, not while it waits.
Credits are used only while a run is working. Between runs, nothing is counted.
Run queue acme / data-jobs
Branches and tags
Deploy exactly the code you choose.
Pick a commit or a tag from any branch. Every run shows which version it used.
Why now
More work runs on automated jobs. Small teams cannot run servers for all of it.
Companies now depend on scheduled jobs and data collection to run their business: reports, syncs, price checks, and scrapers. Each one needs a server, a schedule, and someone to notice when it breaks.
DagFlows turns that work into a push to GitHub. Revenue grows with usage, because teams pay for the compute their runs use.
- runs per month on DagFlows
- [X]
- teams building on DagFlows
- [X]
- month-over-month growth in runs
- [X]%
- market for workflow and data automation
- [$X]B
Figures in square brackets are placeholders for verified data.
What customers say
[Customer quote about what changed after their team moved its jobs to DagFlows.]
- [Logo 1]
- [Logo 2]
- [Logo 3]
- [Logo 4]
- [Logo 5]
Pricing
Pay for what your runs use.
Start free with 200 credits every month. Move up as your usage grows. You never need a card to start.
-
Free
$0
200 credits every month
- Workflows and web scrapers
- Private GitHub repositories
- Build and run history
-
Pro
Recommended$9/ month
2,000 credits every month
- Everything in Free
- Schedules, triggers, and retries
- Team roles and groups
-
Scale
$49/ month
15,000 credits every month
7.5× the credits of Pro
- Everything in Pro
- Room for heavy, frequent jobs
- [Support level]
Business
For larger teams that need more credits, custom terms, or a closer working relationship.
- Custom credit volume
- Everything in Scale
- [Support and terms]
- Cancel anytime
- No commitment
Need more in a month? Top up at any time: $1 buys 200 credits. A run spends credits for the CPU and memory it uses, for each second it runs.