# Dorelli Cloud — complete knowledge base

Generated 2026-09-22 from content/kb.
Individual articles: http://localhost:3000/docs/index.json

## Cancelling and taking your things with you
<!-- http://localhost:3000/docs/account/cancel-and-export · checked 2026-09-14 · evidence: lib/mollie.ts (cancelSubscription), app/actions.ts, lib/backup.ts -->

You can cancel monthly, without a notice period. In the portal, open the site or app, choose cancel, and confirm. The direct debit stops immediately and you keep access until the end of the period you already paid for.

Your site stays online until that date. After it, the site is taken offline and the files are kept for another thirty days, so a change of mind costs nothing. After those thirty days the files and the database are deleted for good.

Take your things with you before the end date:

- **A static site**: download the files from the portal, or use the command line tool, which fetches the same files.
- **An app with a database**: request a database export in the portal. You get a standard dump you can load anywhere.
- **Invoices**: every invoice stays downloadable as PDF in the portal until the end of the retention period.
- **Your domain name**: ask through support for the transfer code. A domain is yours, not ours, and moving it costs nothing here.

Email forwarding stops when the plan stops. Point your MX records at your new provider before the end date so no message is lost.

Cancelling does not delete your account. Your tickets and invoices stay visible, so you can look things up later.

## Your portal account, password and invoices
<!-- http://localhost:3000/docs/account/portal · checked 2026-09-13 · evidence: lib/accounts.ts, app/login/wachtwoord/page.tsx, lib/facturen.ts -->

Your portal account is created automatically after your first payment. You get an email with a link to set your password (valid 24 hours). Forgot your password later? Use the link on the sign-in page; you get a fresh link by email.

In the portal you see your sites and apps, their status and usage, your tickets and your invoices. Every successful payment produces an invoice as PDF, numbered `DH-<year>-<number>`, with the note that no VAT was charged.

During the trial you do not need an account: the management link from your email is your access.

## Cold starts: why the first visit takes 10 to 30 seconds
<!-- http://localhost:3000/docs/apps/cold-start · checked 2026-09-22 · evidence: lib/addons.ts, VERBRUIK-INVOERING.md, lib/bouwstenen/container.ts, app/pricing/page.tsx -->

An app on the App plan scales to zero when nobody visits it. The first visit after a quiet period then starts the container, which takes 10 to 30 seconds (measured: about 22 seconds for a fresh Next app). After that, requests are answered in a fraction of a second until the app goes quiet again.

This is not an outage and the monitoring treats it that way. It is the trade-off that keeps the App plan at € 15: you only use compute while someone is there.

**Do not want to wait?** Switch on the add-on "Always on" under your site's settings in the portal: € 9 a month, and the container keeps running. On the Platform plan you get the same by giving a container a minimum of one instance, at the rate on `/rates`. More in [Why is my app slow after being idle?](/docs/questions/app-slow-after-idle)

## The database of your app
<!-- http://localhost:3000/docs/apps/database · checked 2026-09-13 · evidence: lib/bouwstenen/gedeelde-db.ts, lib/bouwstenen/postgres.ts, VERBRUIK-INVOERING.md -->

On the App plan your app gets its own Postgres database and its own user on a server that is used only for App customers, in the EU (Ireland). The connection string is in `DATABASE_URL`. Limits: 1 GB and 10 connections per app. Use a connection pool in your app; ten connections is enough for a normal Node app but not for one that opens a connection per request.

**Backups:** point-in-time restore of the last 7 days on the server; ask in a ticket if you need a restore. Deleting the app keeps the database 30 days as a backup, then it is dropped.

**Your own server:** on the Platform plan you can switch on a dedicated Postgres server (from small to large) at the rate on `/rates`; a stopped server is kept 7 days, then deleted.

**Export:** ask in a ticket for a `pg_dump` of your database; we provide it as a file.

## Logs, restart and environment variables in your portal
<!-- http://localhost:3000/docs/apps/portal · checked 2026-09-13 · evidence: app/portal/sites/[id]/page.tsx, lib/bouwstenen/container.ts -->

Under **Portal → Sites → your app** you find:

- **Status and replicas:** whether the container runs, the last deploy and the image that is live.
- **Logs:** the last lines of your app on request. This is the first place to look when something is wrong.
- **Restart:** stops and starts the container. Solves most stuck states after a bad deploy.
- **Environment variables:** stored as secrets; shown once when you save them, never again. We can technically read them (that is in the privacy statement); we do not, unless you ask.
- **Database details:** host, database name and user; the password can be reset from the portal.
- **Usage against the plan limits** (database size, connections, traffic).

We support the platform, not your code: if your app crashes because of a bug in the app, the logs are yours to read. Want help with the code? Ask for custom work in a ticket.

## Deploy an app with a database (App plan)
<!-- http://localhost:3000/docs/deploy/app · checked 2026-09-13 · evidence: app/deploy/page.tsx, lib/app-deploy.ts, .github/actions/dorelli-deploy/action.yml -->

Logins, orders, a dashboard with data: then your project is a Node or Next app, not a static site. It runs with us in its own container with its own Postgres database (€ 15 a month after a 14-day trial). The image is built on GitHub, never on our server, so this always goes through a workflow in your repository:

```yaml
name: Deploy app to Dorelli
on:
  push:
    branches: [main]

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dorelli-cloud/cli/.github/actions/dorelli-deploy@v1
        with:
          plan: app
          email: you@example.com
          site-id: ${{ secrets.DORELLI_SITE_ID }}
          deploy-token: ${{ secrets.DORELLI_DEPLOY_TOKEN }}
          registry-user: ${{ secrets.DORELLI_REGISTRY_USER }}
          registry-password: ${{ secrets.DORELLI_REGISTRY_PASSWORD }}
```

The first run creates the site and a registry token and tells you which four secrets to set. Your app gets `DATABASE_URL` and `PORT` (default 3000) as environment variables. No Dockerfile needed: we then use `npm ci`, `npm run build`, `npm start`. Have your own Dockerfile? It is used as is.

The app scales to zero without traffic; the first visit after a quiet period takes 10 to 30 seconds, see [Cold starts](/docs/apps/cold-start). Logs, restart and environment variables are in your portal, see [Logs, restart and variables](/docs/apps/portal).

## Put a Claude artifact or ChatGPT page online
<!-- http://localhost:3000/docs/deploy/claude-artifact · checked 2026-09-13 · evidence: app/live/page.tsx, lib/trial-sites.ts -->

A Claude artifact is a single HTML file. Copy the whole thing, paste it on the upload page at `/live` and your site is online within a minute on `yourname.dorelli.cloud`. Nothing else is needed: no account, no terminal.

This also works for loose HTML from ChatGPT or any other tool. Multiple files (HTML, CSS, images, fonts)? Zip them and upload the zip. There must be an `index.html` at the top level of the zip.

Limits: 50 MB per upload, 500 files. Only static files are served (HTML, CSS, images, fonts, JavaScript that runs in the browser). Server-side code (Node, PHP, Python) is refused; a project with a server and database is the App plan, see [Deploy an app with a database](/docs/deploy/app).

After uploading you get an email with a management link. Keep it: it is your access to the site (redeploy, extend, keep). The trial lasts 14 days and is not indexed by search engines.

## Deploy from Claude Code, Codex or Cursor (one command)
<!-- http://localhost:3000/docs/deploy/cli · checked 2026-09-13 · evidence: packages/dorelli/README.md, app/deploy/page.tsx -->

These tools have a terminal. Ask them to publish your site to Dorelli Cloud, or run it yourself in your project folder:

```bash
npx github:dorelli-cloud/cli deploy dist --email you@example.com
```

The last line of the output is your address. Run it again later in the same folder and you update the same site: the key lives in `.dorelli.json`. Keep that file out of version control and never show its contents. No build folder? Leave out `dist` to publish the current folder.

Add `--yes` to skip confirmations (useful when an agent runs it). `npx github:dorelli-cloud/cli status` shows the state of the site in the current folder.

The first deploy needs a real email address: the management link goes there. Never make one up.

## What works and what does not
<!-- http://localhost:3000/docs/deploy/limits · checked 2026-09-13 · evidence: lib/trial-sites.ts, app/deploy/page.tsx, app/api/deploy/route.ts -->

**Website (€ 10):** HTML, CSS, images, fonts and JavaScript that runs in the browser. Up to 50 MB per upload and 500 files. There must be an `index.html`. No server-side code: `.php`, `.py`, `.env` and similar files are refused with an explanation, and so are paths that point outside the site (zip-slip) and symlinks.

**App (€ 15):** any Node app that listens on a port, with its own Postgres database (1 GB, 10 connections) and 10 GB of traffic a month. 0.25 vCPU and 0.5 GiB memory, scaling to zero.

**Platform:** the whole platform as building blocks at cost plus a small markup: bigger containers, keep-warm, your own database server, cache, file storage, scheduled jobs, extra domains. See [Platform rates](/docs/plans/usage).

**Rate limits:** 5 new sites per hour per IP address and per email address. Every upload is checked for abuse before it is served, see [What gets scanned](/docs/trial/moderation).

Anything beyond this: email support@dorelli.cloud.

## Host a Lovable project on Dorelli Cloud
<!-- http://localhost:3000/docs/deploy/lovable · checked 2026-09-13 · evidence: app/deploy/page.tsx, .github/actions/dorelli-deploy/action.yml -->

Lovable has no button to publish to another host; the way out is GitHub. Connect your project to GitHub (top right in Lovable), then add this file to your repository as `.github/workflows/dorelli.yml`:

```yaml
name: Publish to Dorelli
on:
  push:
    branches: [main]

jobs:
  publish:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
      - run: npm ci && npm run build
      - run: npx github:dorelli-cloud/cli deploy dist --email you@example.com --yes
```

From then on every change in Lovable publishes itself. Your project is built on the servers of GitHub, not ours, which keeps it fast and safe. After the first run the job summary tells you which secrets to set so the next push updates the same site instead of creating a new one.

Does your Lovable project have a backend and a database (logins, orders, a dashboard with data)? Then it is a Node or Next app, not a static site: use the App plan, see [Deploy an app with a database](/docs/deploy/app).

## Use Dorelli Cloud as an MCP tool
<!-- http://localhost:3000/docs/deploy/mcp · checked 2026-09-13 · evidence: packages/dorelli/src/mcp.js, app/deploy/page.tsx -->

Rather have your AI call publishing itself, without a terminal? Add us as an MCP server. In Claude Code that is one line; other MCP clients point at the same command:

```bash
claude mcp add dorelli -- npx -y github:dorelli-cloud/cli mcp
```

Your AI then gets two tools:

- `deploy_site` (directory, email, desired name): publishes a folder; a build folder (dist, build, out, public) is found automatically.
- `site_status` (directory): status and expiry of the site in that folder.

It uses the same `.dorelli.json` as the terminal variant, so a site published from the terminal can be updated through MCP and the other way round.

Agent-native hosting (an MCP endpoint per site with scoped agent keys, logs, metrics and rollback) is on the roadmap; see [Support for agents and AI tools](/docs/support/agents).

## v0, Bolt or any project with a build step
<!-- http://localhost:3000/docs/deploy/v0-bolt · checked 2026-09-13 · evidence: app/deploy/page.tsx -->

Same idea as the terminal route: build your project and publish the output folder. Usually that folder is `dist`, `build` or `out`.

```bash
npm run build
npx github:dorelli-cloud/cli deploy dist --email you@example.com
```

The output must be static (HTML, CSS, JavaScript for the browser). A Next.js project only qualifies with `output: "export"`; a project with API routes or server components is an app and belongs on the App plan, see [Deploy an app with a database](/docs/deploy/app).

## Your own domain name and who owns it
<!-- http://localhost:3000/docs/domains/own-domain · checked 2026-09-21 · evidence: lib/domeinen/catalogus.ts, lib/domeinreis.ts, app/live/claim/page.tsx, app/domains/page.tsx -->

Every paid plan includes one domain name and email forwarding on that domain. You pick the name when you pay: the form checks whether it is free and shows what the extension costs. Standard extensions (.nl, .com, .net, .org, .eu, .be, .dev, .app, .xyz) are included; premium extensions only charge the difference per month. The full list with prices is on our domains page.

After your payment everything happens by itself: we register the domain in your name, point it at your site, set up SSL and forward email to the address you signed up with. You get an email when it is live, usually within the hour. Is your name taken after all? Then we email you free alternatives and you reply with your choice.

**Who owns the domain?** You do. We register it in your name and act as the technical contact so renewals and questions land with us. Want to leave? Request the transfer code from your site's page in the portal; we unlock the domain and email you the code.

**Already have a domain?** Tick "this domain is mine" when you pay. Your domain stays with your current provider; you change two nameservers there, and we do the rest. We email you the two nameservers and remind you once if they are not changed after a few days.

**Extra domains** can be added on every plan under Settings for your site: a standard extension costs 1 euro per month and is free for the first six months; a premium extension costs 2 euros per month plus the difference for that extension.

## Email on your own domain
<!-- http://localhost:3000/docs/email/own-domain · checked 2026-09-14 · evidence: lib/mail.ts, scripts/email-koppelen.sh, lib/cloudflare-dns.ts -->

Every paid plan includes email on your own domain. You do not get a mailbox from us: you get delivery. Mail sent to an address on your domain is forwarded to an inbox you already use, and mail your site sends goes out with your own domain as the sender.

Setting it up happens when your domain is connected. We add the DNS records for you: MX for receiving, and SPF, DKIM and DMARC so your mail is not treated as spam. You tell us which addresses you want and where they should land, for example `info@yourdomain.nl` to your Gmail.

Forwarding keeps working when you later move your mailbox elsewhere. Change the destination and the records stay as they are.

What this is not: a mailbox with its own login, a webmail screen, or shared mailboxes for a team. If you need that, keep your current provider for the mailbox and let us handle only the sending side of your site and app.

Sending from your app works through the platform. Your app calls our mail function and the message goes out from a subdomain we manage, so a misconfigured app can never damage the reputation of your main domain.

Want an address removed? Ask through support and it is gone the same working day.

## The three plans: Website, App and Platform
<!-- http://localhost:3000/docs/plans/plans · checked 2026-09-13 · evidence: app/pricing/page.tsx, lib/config.ts, PRIJZEN-EN-VERBRUIK.md -->

All three plans include a .nl domain, email on your own domain, SSL, daily backup, monitoring and a Dutch invoice. No VAT is added (Dutch small business scheme): the price is the amount you pay. Cancel monthly.

| Plan | Price | For |
|---|---|---|
| Website | € 10 a month | a static site: upload, template, or deploy from your AI tool |
| App | € 15 a month | a Node or Next app with its own database, built with Lovable, v0, Bolt or Claude |
| Platform | € 10 base plus what you use | everything in Website plus the whole platform as building blocks at cost plus a small markup |

**Is € 10 really the final amount?** Yes. We fall under the Dutch small business scheme and charge no VAT. As a business you cannot reclaim anything, but you pay nothing extra either. Above the turnover threshold VAT will be added, with notice in advance.

**Can I switch?** Yes, per month. Between Website and Platform you switch yourself in your portal (the base amount stays € 10). To or from App goes through a ticket, because the direct debit amount changes.

**Can I cancel monthly?** Yes, no strings attached. Your domain goes with you: we transfer it to you or your new provider free of charge.

## Platform: how building blocks are measured and billed
<!-- http://localhost:3000/docs/plans/usage · checked 2026-09-13 · evidence: app/rates/page.tsx, lib/verbruik-meting.ts, lib/afrekenen.ts, lib/tarieven.ts -->

On the Platform plan you pay € 10 a month base (everything in Website) plus what you use, at the rates on `/rates`. Those rates follow the price list of our European cloud partner, including the VAT we cannot reclaim, plus our markup. You pay no VAT on top.

**Building blocks:** containers of any size (with keep-warm), your own Postgres server, cache, file storage, scheduled jobs, extra domains. Before you switch one on you see a cost card with the meters, the rates, the minimum per month and an example. Switching off is deleting; data of databases and storage stays 30 days as a backup.

**Measuring:** containers are measured per minute (allocated compute and memory while an instance runs, requests, outbound traffic). Database servers and cache count per hour they exist; storage per GiB per day. Every day is a line in your portal, rounded up to whole cents per day and per meter, with a CSV export.

**Spending cap:** every site has a cap, default € 50 a month, adjustable up to € 250 yourself. At 80% you get an email; at 100% your containers are paused (databases and storage stay). Raise the cap and everything starts again.

**Settling:** weekly or monthly, on the SEPA mandate from your first payment. Minimum € 10 per direct debit (below that it carries over). You get an email with the exact amount and date at least one day before every debit.

## Which hosting lets a coding agent deploy with its own API key?
<!-- http://localhost:3000/docs/questions/agent-own-api-key · checked 2026-09-22 · evidence: lib/agent-sleutels.ts, lib/agent-grenzen.ts, lib/mcp.ts, lib/oauth.ts -->

Dorelli Cloud does. On the Agents tab of your site in the portal you create a key for the agent, choose its rights (publish, read status, read logs, read form counts, read the audit log, read limits) and get the key once. The agent uses it as a bearer token on the site's MCP server or on the API. What it does is logged; what it may not do is refused with an error that names the page where you grant the right. Available on every plan, from € 10 a month.

| Agent keys | |
|---|---|
| Rights | six, chosen per key; a key without a right cannot use the matching tool |
| Keys per site | 3 on Website, 5 on App, 10 on Platform |
| Deploys per day | 50 on Website, 20 on App, unlimited within the cap on Platform |
| Audit log | who did what, with which key, outcome and time; refused actions too; never the content of a deploy |
| Revoke | one click in the portal; the key stops working at once |
| Connectors | claude.ai and ChatGPT use OAuth instead: a consent screen, a token that expires after a day |

Give the key to Claude Code, and the site's MCP server does the rest:

```bash
claude mcp add --transport http dorelli https://mcp.dorelli.cloud/<your-site> --header "Authorization: Bearer <agent key>"
```

Without MCP, the same key works on the HTTP API described in [our OpenAPI file](/openapi.json): `POST /api/deploy` publishes, `PUT /api/deploy/{id}` updates, `GET /api/deploy/{id}` shows status. Before a site is claimed, an agent can already publish a 14-day trial site with only an email address; the key comes when you keep the site.

Keep the key secret and give it no more rights than the job needs. An agent with a key acts on your behalf: we log everything and the limits are hard, but what it does within them is yours.

### Not for

Keys that must span several sites (one key, one site), rights that change infrastructure (rollback, database, secrets, restart are not in the list yet), and per-key spending budgets; spending is capped per site, not per key.

## My AI-built app needs a database. Where do I put it?
<!-- http://localhost:3000/docs/questions/ai-app-needs-database · checked 2026-09-22 · evidence: lib/config.ts, lib/bundelgrenzen.ts, content/kb/apps/database.md, content/kb/deploy/app.md -->

Next to the app, on the same plan. On our App plan (€ 15 a month, first 14 days free) your app gets its own Postgres database on a server in the EU, and the connection string arrives in the environment variable `DATABASE_URL`. Nothing to sign up for elsewhere, and the database is in the nightly backup together with the platform.

| Database on the App plan | |
|---|---|
| Type | Postgres, own database and own user on a server used only for App customers |
| Size | 1 GB, 10 connections; use a connection pool in your app |
| Where | Dublin, EU; the app itself runs in Amsterdam |
| Backups | point-in-time restore for the last 7 days; the platform backup every night |
| Access | host, name and user in your portal; the password can be reset there |
| Export | ask for a `pg_dump` in a ticket, you get a file |
| Deleted app | the database is kept 30 days, then dropped |

Your code needs one thing: read `DATABASE_URL` instead of a hard-coded address. Prisma, Drizzle, `pg` and Knex all do that by default. Then one workflow file in your repository builds the image on GitHub and deploys it:

```yaml
- uses: dorelli-cloud/cli/.github/actions/dorelli-deploy@v1
  with:
    plan: app
    email: you@example.com
```

The full file and the secrets it asks for are in [Deploy an app with a database](/docs/deploy/app).

Did the AI build on SQLite? That works too as long as you accept that a container which scales to zero keeps no local files; move the data to Postgres before it matters. Did it build on Supabase or Firebase? Then the database already has a home and you only need the Website plan for € 10.

### Not for

More than 1 GB of data or 10 connections, MySQL, MongoDB or Redis (Redis is a building block on the Platform plan), or a database that other systems must reach from outside; the App database is reachable from your container only. Bigger and dedicated Postgres servers are on the [Platform plan](/docs/plans/usage).

## Why is my app slow after being idle?
<!-- http://localhost:3000/docs/questions/app-slow-after-idle · checked 2026-09-22 · evidence: lib/addons.ts, lib/config.ts, content/kb/apps/cold-start.md, content/talen/en.json -->

Because it was switched off. An app on the App plan scales to zero when nobody visits it, and the first visit after a quiet period starts the container again. That takes 10 to 30 seconds (we measured about 22 seconds for a fresh Next app). After that, every request is answered in a fraction of a second until the app goes quiet again. This is the trade-off that keeps the plan at € 15 a month: you use compute only while someone is there.

| Situation | What you see | What to do |
|---|---|---|
| First visit after idle | 10 to 30 seconds of waiting | nothing, or keep the app warm |
| Every visit after that | normal speed | nothing |
| Slow on every request | not a cold start | check the logs in your portal; usually the database or an external call |
| Cold starts hurt your business | customers leave before the page shows | add the "Always on" option for € 9 a month |

"Always on" is an add-on on the App plan; you switch it on under your site's settings in the portal and the container keeps running, so the first visit is as fast as the tenth. On the Platform plan you get the same by giving a container a minimum of one instance, at the rate on [the rates page](/rates).

Two things that make a cold start slower than it needs to be: a heavy start-up (migrations, large imports, warming caches at boot) and a slow health check. Keep the start light and let the app listen on `PORT` as early as it can. Check what happened around a slow request:

```bash
npx github:dorelli-cloud/cli status
```

And the logs and restart button are in your portal, see [Your app in the portal](/docs/apps/portal).

### Not for

A static site on the Website plan never has a cold start; there is no container to start. If a static site is slow, the cause is in the page itself (large images, blocking scripts), not in the hosting.

## How do I put a Bolt app online with a custom domain?
<!-- http://localhost:3000/docs/questions/bolt-app-custom-domain · checked 2026-09-22 · evidence: content/kb/deploy/v0-bolt.md, content/kb/deploy/app.md, lib/domeinreis.ts, lib/config.ts -->

Download or export your Bolt project, build it, publish the output folder with one command, and pick your domain name when you pay. A static Bolt site costs € 10 a month with the domain, email forwarding and SSL included; a Bolt app with a backend and database is € 15. The first 14 days are free on a `yourname.dorelli.cloud` address.

| Step | Static site (most Bolt projects) | App with its own server |
|---|---|---|
| Get the code | export from Bolt, or push to GitHub | push to GitHub |
| Publish | `npm run build`, then the command below | one workflow file in the repo |
| Domain | choose it when you pay, we register it in your name | same |
| Price | € 10 a month | € 15 a month |

From the project folder:

```bash
npm run build
npx github:dorelli-cloud/cli deploy dist --email you@example.com
```

The last line of the output is your address. The email you get has the management link; from there you pay and enter the domain name you want. Is the name taken? We email you free alternatives. Already own a domain? Tick "this domain is mine" and change two nameservers at your provider, see [Your own domain](/docs/domains/own-domain).

Does your Bolt project have an Express or Node server with its own database? Then use the App route from [Deploy an app with a database](/docs/deploy/app); the container and a Postgres database come with it.

### Not for

Projects that Bolt built on Supabase or Firebase do not need our App plan: keep that backend, host the front end here for € 10. Not for server code in another language than Node, and not for a domain with an extension we do not register (the list is on [the domains page](/domains)).

## How do I cap what an agent spends on hosting?
<!-- http://localhost:3000/docs/questions/cap-agent-spending · checked 2026-09-22 · evidence: lib/config.ts, lib/agent-grenzen.ts, lib/agent-sleutels.ts, content/kb/plans/usage.md -->

By choosing a plan where the agent cannot spend at all, or by setting the cap yourself. On the Website plan (€ 10 a month) and the App plan (€ 15) the price is fixed: an agent can deploy, but no action it takes adds a cent to the invoice. On the Platform plan the spending cap per site is the ceiling: default € 50 a month, adjustable up to € 250, and at 100% the containers pause until you raise it.

| Where an agent could cost money | What stops it |
|---|---|
| Deploying too often | 50 deploys a day on Website, 20 on App; more is refused |
| Switching on building blocks | not a right an agent has; building blocks are switched on by you in the portal |
| Usage on Platform | the cap you set; email at 80%, pause at 100% |
| Creating extra sites | a new trial site needs an email address and is free for 14 days; keeping one is a payment you make |
| Doing things you did not intend | rights per key; a missing right returns an error, and every action is in the audit log |

A key never carries a payment method. Paying, upgrading and switching on building blocks stay actions of a person in the portal, so the worst an agent can do on a fixed plan is publish a version you did not want. That you fix with a new deploy.

Give the agent a key with only the rights it needs, and add the site's MCP server to your tool:

```bash
claude mcp add --transport http dorelli https://mcp.dorelli.cloud/<your-site> --header "Authorization: Bearer <agent key>"
```

The agent can read its own limits and today's usage with the `limits` tool, so a well-behaved agent stops before we have to stop it. The audit log in your portal shows every action, including the refused ones, for 30 days on Website and 90 days on App and Platform.

### Not for

A budget per key: the cap is per site, and a fixed plan has no meter to cap. Not for agents that must buy things (domains, add-ons, bigger containers) on their own; that needs a person, on purpose.

## Is there a cheap European host with domain and email included?
<!-- http://localhost:3000/docs/questions/cheap-european-host-domain-email · checked 2026-09-22 · evidence: lib/config.ts, lib/domeinen/catalogus.ts, content/kb/domains/own-domain.md, content/kb/email/own-domain.md -->

Yes: € 10 a month at Dorelli Cloud gets you hosting for a static site, one domain name registered in your name, email forwarding on that domain, SSL, daily backups and monitoring, on one Dutch invoice with no VAT added. Standard extensions such as .nl, .com, .eu, .be, .org and .dev are included in the price; a premium extension only costs the difference.

| | Dorelli Cloud, Website plan | A classic shared host |
|---|---|---|
| Price | € 10 a month, no VAT added, cancel monthly | often cheaper on paper, then VAT, setup fee and a yearly domain bill |
| Domain | one included, in your name, transfer code on request | usually a separate line item |
| Email | forwarding to an inbox you already use, SPF, DKIM and DMARC set for you | mailboxes with webmail, often included |
| Runs | static files: HTML, CSS, JavaScript in the browser, images | PHP, WordPress, databases on shared servers |
| Deploy | paste, upload, one command, or a GitHub workflow | FTP or a file manager |
| Support | a human within one business day; an AI assistant for documented questions | ticket or phone |

The difference that matters: a classic host runs your PHP on a shared server; we serve files and run Node apps in their own container. That is why we can skip the account and the credit card for a 14-day trial, and why WordPress is not on the menu.

Try it in a minute, from the folder with your site:

```bash
npx github:dorelli-cloud/cli deploy --email you@example.com
```

Or paste one HTML file on [the upload page](/live). Keeping it with your own domain is one iDEAL payment of € 10.

### Not for

WordPress, Joomla or any PHP site; a team that needs real mailboxes with webmail (we forward, we do not store mail); a shop that needs more than one small Node container. Extra domains cost € 1 a month for a standard extension, free for the first six months, and € 2 plus the difference for a premium one.

## How do I put a Claude artifact on my own domain?
<!-- http://localhost:3000/docs/questions/claude-artifact-own-domain · checked 2026-09-22 · evidence: app/live/page.tsx, lib/trial-sites.ts, lib/domeinreis.ts, lib/config.ts -->

Copy the whole artifact, paste it on [our upload page](/live), and it is online within a minute on `yourname.dorelli.cloud`. To move it to your own domain you pay € 10 a month from the management link in your email; we register the domain in your name, or connect one you already own, and set up SSL and email forwarding. Usually the domain is live within the hour.

| Step | What happens |
|---|---|
| 1. Paste | the artifact is one HTML file; paste it, or upload a zip with an `index.html` at the top |
| 2. Trial | 14 days on `yourname.dorelli.cloud`, no account, not indexed by search engines |
| 3. Keep it | pay € 10 via iDEAL, pick your domain name in the form, done |
| Included | domain (.nl, .com, .eu and other standard extensions), email forwarding, SSL, daily backup, monitoring |

Rather do it from a terminal? In the folder with the file:

```bash
npx github:dorelli-cloud/cli deploy --email you@example.com
```

Already own the domain? Tick "this domain is mine" when you pay. You change two nameservers at your current provider and we do the rest, see [Your own domain](/docs/domains/own-domain).

This also works for loose HTML from ChatGPT or any other tool. The limits are 50 MB per upload and 500 files.

### Not for

An artifact that calls a server: Node, PHP or Python code is refused, and a project with a database is the [App plan](/docs/deploy/app) (€ 15). A React artifact that Claude shows as a preview is also not a plain HTML file; ask Claude to export it as a single HTML file first.

## How do I deploy a site from Claude Code with one command?
<!-- http://localhost:3000/docs/questions/claude-code-one-command · checked 2026-09-22 · evidence: packages/dorelli/src/cli.ts, packages/dorelli/skill/SKILL.md, lib/llms.ts, lib/config.ts -->

Ask Claude Code to publish the site to Dorelli Cloud, or run this yourself in the project folder:

```bash
npx github:dorelli-cloud/cli deploy dist --email you@example.com --yes
```

The last line of the output is the address, live within a minute on `yourname.dorelli.cloud`. No account, no token to create first. Run it again in the same folder and the same site is updated; the key lives in `.dorelli.json`, which you keep out of version control. The trial is 14 days; keeping the site with your own domain, email and SSL is € 10 a month.

| Detail | Value |
|---|---|
| Command | `npx github:dorelli-cloud/cli deploy [folder] --email <you> --yes` |
| Folder | `dist`, `build` or `out`; leave it out to publish the current folder |
| `--yes` | skips the confirmation, so an agent can run it unattended |
| Status | `npx github:dorelli-cloud/cli status` in the same folder |
| Limits | 50 MB per upload, 500 files, static files only |
| Price | free for 14 days, then € 10 a month with domain, email forwarding, SSL, backup and monitoring |

Prefer a tool over a command? Add us as an MCP server and Claude Code gets `deploy_site` and `site_status`:

```bash
claude mcp add dorelli -- npx -y github:dorelli-cloud/cli mcp
```

Claude Code reads [our llms.txt](/llms.txt) as well, so "publish this to Dorelli" is usually enough. The email address must be real: the management link goes there.

### Not for

A Next.js project with server components or API routes: that is an app, not a static site, and goes through a GitHub workflow on the [App plan](/docs/deploy/app) (€ 15). Also not for a folder without an `index.html`.

## How do I let Cursor or Codex deploy without manual steps?
<!-- http://localhost:3000/docs/questions/cursor-codex-deploy · checked 2026-09-22 · evidence: packages/dorelli/src/cli.ts, lib/agents-md.ts, lib/agent-grenzen.ts, lib/mcp.ts -->

Give the agent a command it can run without questions, and a place to read the rules. The command is one line with `--yes`, so nothing waits for a keypress; the rules are an `AGENTS.md` you download from the portal and put in the root of the repository. Cursor and Codex read that file on their own.

```bash
npx github:dorelli-cloud/cli deploy dist --email you@example.com --yes
```

The first run publishes a trial site for 14 days and writes `.dorelli.json` in the folder, so every later run updates the same site. Keeping it with your own domain is € 10 a month; an app with a database is € 15.

| Without manual steps | How |
|---|---|
| Publish | the command above, or the `deploy_site` tool on the MCP server |
| Know the rules | `AGENTS.md` per site from the portal: address, commands, limits |
| Check the result | `npx github:dorelli-cloud/cli status`, or `site_status` on MCP |
| Read logs, submissions, usage | an agent key with only those rights |
| Stay in control | every action lands in an audit log; deploys per day are capped |

For a claimed site you can give the agent its own key with only the rights it needs (publish, read status, read logs) and point it at the site's MCP server:

```bash
claude mcp add --transport http dorelli https://mcp.dorelli.cloud/<your-site> --header "Authorization: Bearer <agent key>"
```

Cursor and Codex take the same URL and header in their MCP settings. Everything the agent does is in the audit log in your portal, and on the Website plan an agent may deploy 50 times a day. See [Hosting your agent can operate](/agents).

### Not for

Apps with a database: those are built on GitHub through a workflow, so the agent's job is to push, not to deploy. Not for teams that need one key shared by several agents with different rights; one key has one set of rights.

## Which hosting keeps my data in the EU?
<!-- http://localhost:3000/docs/questions/data-stays-in-eu · checked 2026-09-22 · evidence: lib/config.ts, content/talen/en.json, content/kb/security/backups.md, app/dpa/page.tsx -->

At Dorelli Cloud your site, its files and its backups sit in Amsterdam, and your account, invoices and app databases sit in Dublin. Both are EU regions of our European cloud partner; nothing of yours is stored outside the EU. A data processing agreement is ready on [the DPA page](/dpa), and we set no tracking cookies on your site or ours. This is included in every plan, from € 10 a month.

| What | Where | Kept |
|---|---|---|
| Site files, app container | Amsterdam (West Europe) | as long as the site exists, 30 days after cancellation |
| App database (Postgres) | Dublin (North Europe) | 30 days after deletion as a backup |
| Nightly backup of the platform | storage in the Netherlands | 90 days, checked every night |
| Account, invoices, tickets | Dublin | as long as required for the books |
| Traffic | through a security shield at the edge, then to Amsterdam | request logs, not content |

One exception you should know about: the visible text of a new trial site briefly passes an AI moderation scan before it is published, so that nobody can use a trial address for phishing. Only that text, only once, and nothing is kept from it. That is in the privacy statement, not hidden in a footnote.

You can check the location yourself: every app receives `DATABASE_URL` with a host in the EU, and the address of the platform resolves to our partner's Amsterdam region. Try the trial without an account:

```bash
npx github:dorelli-cloud/cli deploy --email you@example.com
```

### Not for

Organisations that require data to stay within one country (the database is in Ireland, not the Netherlands), or that forbid any US-based sub-processor: our cloud partner and the moderation model are run by US companies from EU regions, and the DPA lists them. Not for workloads that need a specific certification such as ISO 27001 on our side; we are a small company and do not hold one.

## Domain, DNS and SSL explained for someone building with AI
<!-- http://localhost:3000/docs/questions/domain-dns-ssl-explained · checked 2026-09-22 · evidence: lib/domeinreis.ts, lib/domeinen/rand.ts, content/kb/domains/own-domain.md, lib/config.ts -->

A domain is the name people type, DNS is the phone book that turns the name into an address, and SSL is the padlock that proves the address is really yours. You need all three, and on Dorelli Cloud you get all three in the € 10 a month: we register the domain in your name, set the DNS records and arrange the certificate. If you already own a domain, you change two nameservers once and we do the rest.

| Term | What it is | Who does it here |
|---|---|---|
| Domain | your name, such as `bakery-jansen.nl`, rented per year from the registry | we register it in your name and renew it; you get the transfer code whenever you ask |
| DNS | records that say where the name points: the site, the mail, the proof for the certificate | we set them; with your own domain, you point the nameservers at us once |
| Nameservers | the two addresses at your registrar that say who manages your DNS | you change these once if you bring your own domain |
| SSL (TLS) | the certificate behind `https://` and the padlock | we request it and renew it automatically; nothing to install |
| Propagation | the hours it can take before every network sees a DNS change | usually under an hour; we email you when the domain is live |

What the AI did not tell you: the site your tool built has no name yet. `yourname.dorelli.cloud` is a trial address for 14 days. Keeping it means picking a domain when you pay; the form checks whether the name is free and shows the price per extension (.nl, .com, .eu and other standard extensions are included).

Bringing your own domain from another provider? Tick "this domain is mine" when you pay. We email you the two nameservers; you paste them at your registrar. We remind you once if nothing has changed after a few days. Details in [Your own domain](/docs/domains/own-domain).

Start with the trial, no domain needed yet:

```bash
npx github:dorelli-cloud/cli deploy --email you@example.com
```

### Not for

Domains with an extension we do not register (the list is on [the domains page](/domains)); DNS records you want to manage record by record (we set them for you and change them on request); and wildcard or client certificates. Also not for two-level subdomains on the trial address: the certificate covers one level, so `shop.yourname.dorelli.cloud` does not work.

## Dorelli or Vercel for a European site?
<!-- http://localhost:3000/docs/questions/dorelli-vs-vercel · checked 2026-09-22 · evidence: lib/config.ts, lib/bundelgrenzen.ts, content/kb/plans/plans.md, content/talen/en.json -->

Vercel if you build a Next.js app that leans on their edge network and their previews, and you are fine with a US company and a per-seat price. Dorelli if you want one fixed price in euros with a domain, email and an invoice you can book, and your data in the Netherlands. Vercel's free plan is for non-commercial use only; our trial is 14 days and then € 10 a month for a site or € 15 for an app.

| | Dorelli Cloud | Vercel (prices checked 22 September 2026) |
|---|---|---|
| Price | € 10 a month site, € 15 app, no VAT added | Hobby $0 (personal, non-commercial), Pro $20 a month per developer seat |
| Domain and email | one domain and email forwarding included | you bring your own domain; no email |
| Invoice | Dutch invoice, iDEAL and SEPA direct debit | card, US invoice |
| Where data sits | Amsterdam (site, backups), Dublin (accounts, app databases) | global edge network; function region selectable |
| Database | Postgres included on the App plan (1 GB) | via marketplace partners, paid separately |
| Cold start | app scales to zero, 10 to 30 s after idle; keep-warm € 9 | serverless functions, usually faster cold starts |
| Support | a human within one business day | community on Hobby, email on Pro |

Where Vercel is better: preview deployments per pull request, Edge Middleware, image optimisation at the edge, and everything Next.js supports on the day it ships. Where we are better: the total price for a small business site, the domain and email in the same invoice, and the fact that nobody in the Netherlands needs to explain a dollar charge to their accountant.

Try it without an account, from the folder with your built site:

```bash
npx github:dorelli-cloud/cli deploy out --email you@example.com
```

### Not for

A Next.js app that uses Vercel-only features (Edge Middleware, ISR on the edge, Vercel Blob or KV): moving it here means rewriting those parts. Not for teams that live in preview deployments; we deploy what you send, one version per site.

## Is there hosting my coding agent can operate itself?
<!-- http://localhost:3000/docs/questions/hosting-agent-operates · checked 2026-09-22 · evidence: lib/agent-grenzen.ts, lib/mcp.ts, lib/agent-sleutels.ts, lib/agents-md.ts, lib/webhooks.ts -->

Yes. Dorelli Cloud gives every site its own MCP server and lets you create keys for your agent with exactly the rights you choose: publish, read status, read logs, read form counts, read the audit log, read limits. The agent deploys, checks and reads on its own; every action lands in an audit log you can read, and the limits are enforced by the code, not by a promise. Included in every plan, from € 10 a month.

| Per plan | Website (€ 10) | App (€ 15) | Platform (€ 10 + usage) |
|---|---|---|---|
| Agent keys per site | 3 | 5 | 10 |
| Deploys per day by an agent | 50 | 20 | unlimited within your spending cap |
| Webhooks per site | 1 | 3 | 10 |
| Audit log kept | 30 days | 90 days | 90 days, with CSV export |

Live in a minute: put a site online, claim it in the portal, create a key on the Agents tab, and add the site's MCP server to your tool. In Claude Code:

```bash
claude mcp add --transport http dorelli https://mcp.dorelli.cloud/<your-site> --header "Authorization: Bearer <agent key>"
```

Codex, Cursor and other MCP clients take the same URL and header. The tools the agent then has are `deploy_site`, `site_status`, `site_log`, `form_submissions`, `audit_log` and `limits`, each only if the key has that right. A right the key lacks returns an error with the page where you grant it.

Connectors in claude.ai and ChatGPT do not need a key: they ask for consent through OAuth, you pick the site and the rights, and the token expires after a day. Download an `AGENTS.md` per site from the portal and any coding agent knows how to deploy here and where the logs are.

Before the first key, the agent can already publish without any account:

```bash
npx github:dorelli-cloud/cli deploy dist --email you@example.com --yes
```

### Not for

Agents that need to change infrastructure: rollback, database access, secrets, restarts and building blocks on a budget are not in the rights yet; they come after proof with real agents. Not for one shared key with several agents behind it; make one key per agent so the audit log tells them apart.

## Where do I host a website I built with AI?
<!-- http://localhost:3000/docs/questions/hosting-ai-built-website · checked 2026-09-22 · evidence: app/deploy/page.tsx, lib/trial-sites.ts, lib/config.ts, content/kb/plans/plans.md -->

Here, on a Dutch host built for exactly that. A site from Claude, ChatGPT, Lovable, v0, Bolt, Cursor or Codex goes online in a minute on a trial address, free for 14 days, and for € 10 a month it gets your own domain, email on that domain, SSL, daily backups and monitoring. An app with its own database is € 15. No VAT is added and you can cancel monthly.

| Built with | Route | Plan |
|---|---|---|
| Claude or ChatGPT (one HTML file) | paste it on [the upload page](/live) | Website, € 10 |
| Claude Code, Cursor, Codex | one command in the project folder | Website, € 10 |
| Lovable, v0, Bolt: front end only | build, publish the output folder | Website, € 10 |
| Lovable, v0, Bolt: with backend and database | GitHub workflow, own container | App, € 15 |

The command for the terminal tools:

```bash
npx github:dorelli-cloud/cli deploy dist --email you@example.com
```

What makes this different from a general host: no server-side code is executed on the Website plan, which is why the trial needs no account and no card. Every upload is checked for abuse before it is served, and the files stay in Amsterdam. Support is a human within one business day, in Dutch or English.

Not sure whether your project is a site or an app? Read [Is my project a static site or an app?](/docs/questions/static-site-or-app)

### Not for

WordPress, PHP or Python: we run static files and Node apps, nothing else. Not for sites above 50 MB or 500 files, and not for shops or platforms that need more than one small container; those grow into the [Platform plan](/docs/plans/usage), where you pay for what you use.

## How do I know upfront what hosting will cost per month?
<!-- http://localhost:3000/docs/questions/hosting-cost-upfront · checked 2026-09-22 · evidence: lib/config.ts, lib/addons.ts, lib/domeinen/catalogus.ts, content/kb/plans/usage.md -->

On the Website and App plans the answer is one number: € 10 or € 15 a month, no VAT added, with the domain, email forwarding, SSL, backups and monitoring inside that number. There is no traffic bill, no build-minute bill and no surprise. On the Platform plan you pay for what you use, and there a spending cap you set yourself (default € 50 a month) is the ceiling.

| Plan | Fixed per month | Can anything come on top? |
|---|---|---|
| Website | € 10 | only add-ons you switch on yourself: an extra domain (€ 1, or € 2 for a premium extension) |
| App | € 15 | "Always on" for € 9 if you want no cold starts; an extra domain as above |
| Platform | € 10 base | usage at the rates on `/rates`, never above the cap you set (default € 50, up to € 250) |
| Trial | € 0 for 14 days | nothing; the trial ends by itself if you do nothing |

Two things keep the App plan predictable: traffic is included up to 10 GB a month and the database up to 1 GB, and we do not charge per request or per build. Reach a limit and you get an email with what to do; nothing is added to the invoice on its own.

On Platform every building block shows a cost card before you switch it on: the meters, the rate, the minimum per month and an example. At 80% of your cap you get an email; at 100% your containers pause until you raise the cap. Every day is a line in your portal with a CSV export, and you get an email with the exact amount at least one day before every direct debit.

Prices are also machine-readable, if you want a script or an agent to check them:

```bash
curl https://dorelli.cloud/prijzen.json
```

Domain prices per extension are on [the domains page](/domains); a premium extension costs only the difference above what the plan covers, shown before you choose.

### Not for

Anyone who needs a fixed price for a large workload: on Platform the bill follows usage, and the cap protects you from a runaway, not from a busy month. Not for VAT-registered businesses expecting to reclaim VAT; we charge none, so there is nothing to reclaim.

## Which hosts publish an llms.txt for agents?
<!-- http://localhost:3000/docs/questions/hosts-with-llms-txt · checked 2026-09-22 · evidence: lib/llms.ts, app/llms.txt/route.ts, app/llms-full.txt/route.ts, app/openapi.json/route.ts, lib/entiteit.ts -->

Dorelli Cloud does: [dorelli.cloud/llms.txt](/llms.txt) is the short version of how to publish here, with the exact commands, and [llms-full.txt](/llms-full.txt) is the whole documentation as one plain-text file. Both are meant to be read by an agent before it acts, so that "publish this to Dorelli" works in one go. We cannot tell you which other hosts do this reliably, because the list changes weekly; check `https://<host>/llms.txt` yourself.

| Machine-readable at Dorelli Cloud | Address | What is in it |
|---|---|---|
| Short instructions | `/llms.txt` (per language: `/nl/llms.txt`, `/de/llms.txt`) | the deploy command, the MCP line, the API, the limits, what to tell the user |
| Everything | `/llms-full.txt` | all documentation articles in one file |
| Every article as markdown | `/docs/<article>.md`, index at `/docs/index.json` | the same text the page shows, without layout |
| Deploy API | `/openapi.json` | `POST /api/deploy`, `PUT /api/deploy/{id}`, `GET /api/deploy/{id}` |
| Prices and rates | `/prijzen.json`, `/tarieven.json` | the numbers the site shows, from the same source |
| Who we are | `/entiteit.json` | name, legal entity, plans with prices, where else we are listed |
| Per site | `AGENTS.md` from the portal | how this site deploys, where its logs are, which limits apply |

Fetch it and you have what an agent needs:

```bash
curl https://dorelli.cloud/llms.txt
```

The commands in it are the same as in the docs and in the CLI package, and a test checks that they stay the same. The prices come from the same configuration as the pricing page, so the file cannot quietly lag behind. Hosting a site is € 10 a month, an app with a database € 15, and the first 14 days are free.

We also let AI crawlers in on purpose. Customer trial sites stay `noindex`, but our own pages, docs and these files are open to them.

### Not for

An agent that expects a full control API: `llms.txt` describes publishing, status and the limits, not account management or payments; those stay with a person in the portal. And the file describes us, not your site: for that, download the `AGENTS.md` of the site.

## Where do I host a Lovable app with a database in Europe?
<!-- http://localhost:3000/docs/questions/lovable-app-database-europe · checked 2026-09-22 · evidence: lib/config.ts, lib/bundelgrenzen.ts, content/kb/deploy/app.md, .github/actions/dorelli-deploy/action.yml -->

A Lovable app with logins, orders or a dashboard is a Node app with a database, and you can host it on our App plan for € 15 a month, in the EU. Your app runs in its own container in Amsterdam and gets its own Postgres database in Dublin. The connection string arrives in `DATABASE_URL`, so the code Lovable generated keeps working. First 14 days are free.

| What you get | On the App plan |
|---|---|
| Container | 0.25 vCPU, 0.5 GiB memory, scales to zero when nobody visits |
| Database | own Postgres, 1 GB, 10 connections, server in the EU (Ireland) |
| Traffic | 10 GB a month |
| Included | domain name, email on that domain, SSL, daily backup, monitoring, Dutch invoice |
| Price | € 15 a month, no VAT added, cancel monthly |

Lovable has no button to publish elsewhere. The way out is GitHub: connect your project (top right in Lovable) and add one workflow file. The image is built on GitHub, never on our server.

```yaml
- uses: dorelli-cloud/cli/.github/actions/dorelli-deploy@v1
  with:
    plan: app
    email: you@example.com
```

The first run creates the app and tells you which secrets to set. Every push after that updates the same app. The full file is in [Deploy an app with a database](/docs/deploy/app).

Does your Lovable project use Supabase? Then it already has a database, and what you need from us is the Website plan (€ 10): the front end is static and Supabase keeps doing the data. See [Is my project a static site or an app?](/docs/questions/static-site-or-app)

### Not for

An app that needs more than 1 GB of data or 10 database connections, an app that must answer within a second after a quiet night (the first visit after idle takes 10 to 30 seconds, unless you add keep-warm for € 9 a month), or anything that is not Node. Bigger containers and your own database server are on the Platform plan.

## Is there an MCP server for publishing a website?
<!-- http://localhost:3000/docs/questions/mcp-server-publish-website · checked 2026-09-22 · evidence: packages/dorelli/src/mcp.ts, lib/mcp.ts, lib/agent-grenzen.ts, packages/dorelli/server.json -->

Yes, two of them. A local MCP server that publishes a folder from your machine, for Claude Code, Codex, Cursor or any MCP client, without an account; and a remote MCP server per site, with an agent key, for everything a claimed site can do. Both are included: the trial is free for 14 days and keeping a site is € 10 a month, or € 15 for an app.

| | Local MCP server | Remote MCP server per site |
|---|---|---|
| Runs | on your machine, via `npx` | at `https://mcp.dorelli.cloud/<your-site>` |
| Needs | nothing; an email address on the first deploy | an agent key from the portal, or OAuth in claude.ai and ChatGPT |
| Tools | `deploy_site` (directory, email, name), `site_status` (directory) | `deploy_site`, `site_status`, `site_log`, `form_submissions`, `audit_log`, `limits` |
| Transport | stdio | streamable HTTP, sessionless |
| Best for | "publish this folder" from a coding tool | an agent that operates a site you already keep |

Add the local one to Claude Code with one line; other clients point at the same command:

```bash
claude mcp add dorelli -- npx -y github:dorelli-cloud/cli mcp
```

Your AI then calls `deploy_site` with the folder and your email, and answers with the address. A build folder (`dist`, `build`, `out`, `public`) is found by itself. The key for updates lives in `.dorelli.json` in that folder.

The remote server needs a key with rights you choose on the Agents tab of your site:

```bash
claude mcp add --transport http dorelli https://mcp.dorelli.cloud/<your-site> --header "Authorization: Bearer <agent key>"
```

Every call is a line in the audit log of the site. The package is also on GitHub as `dorelli-cloud/cli`, with a plugin for Claude Code in `dorelli-cloud/plugins`.

### Not for

Building an app image: an app with a database is built on GitHub through a workflow, and `deploy_site` on the App plan takes a finished image, not source code. Not for clients that only speak the old SSE transport; the remote server uses streamable HTTP.

## Is there a Netlify alternative with an EU invoice?
<!-- http://localhost:3000/docs/questions/netlify-alternative-eu-invoice · checked 2026-09-22 · evidence: lib/config.ts, lib/facturen.ts, lib/mollie.ts, content/kb/account/portal.md -->

Yes. Dorelli Cloud hosts static sites the way Netlify does, for € 10 a month with a Dutch invoice as PDF after every payment, paid by iDEAL and then SEPA direct debit. No VAT is added under the Dutch small business scheme, so the amount on the invoice is the amount you pay. The domain name and email forwarding are in the same € 10.

| | Dorelli Cloud | Netlify (prices checked 22 September 2026) |
|---|---|---|
| Price | € 10 a month, no VAT added | Free $0, Personal $9, Pro $20 a month |
| Invoice | Dutch PDF invoice per payment, numbered, bookable | card payment, US invoice |
| Domain and email | one domain and email forwarding included | own domain, no email |
| Deploy | one command, upload page, or GitHub workflow | Git push with build on their side |
| Build | you build (locally or on GitHub), we serve | Netlify builds, minutes are metered |
| Forms | contact form module included, submissions to your inbox | forms on paid plans |
| Data | files in Amsterdam, moderation scan before publishing | global CDN |

What Netlify does better: build in their pipeline from a Git push, deploy previews per branch, serverless functions and edge functions, and a large plugin ecosystem. What we keep simple: you publish the output folder, we serve it from the Netherlands behind a security shield, and one invoice covers hosting, domain and email.

From the folder with your built site:

```bash
npm run build
npx github:dorelli-cloud/cli deploy dist --email you@example.com
```

The first 14 days are free on `yourname.dorelli.cloud`, without an account.

### Not for

Sites that depend on Netlify Functions, Edge Functions or Netlify Identity: we run static files only on this plan, and a Node backend is the [App plan](/docs/deploy/app) at € 15. Not for sites above 50 MB or 500 files.

## Railway or Render for a small Node app with a database?
<!-- http://localhost:3000/docs/questions/railway-render-small-node-app · checked 2026-09-22 · evidence: lib/config.ts, lib/bundelgrenzen.ts, lib/addons.ts, content/kb/apps/cold-start.md -->

For a small Node app with a database that has to earn its keep in Europe, the honest comparison is on price certainty and on what is included. Railway charges by usage on top of a plan fee; Render's free tier sleeps and its free database expires; both bill in dollars. Dorelli's App plan is € 15 a month flat, with a Postgres database, a domain, email forwarding and a Dutch invoice, and the app runs in Amsterdam with its database in Dublin.

| | Dorelli App plan | Railway (checked 22 September 2026) | Render (checked 22 September 2026) |
|---|---|---|---|
| Price | € 15 a month flat, no VAT added | Hobby $5 a month plus usage: $20 per vCPU and $10 per GB memory per month | free web service that sleeps; paid instances per month |
| Database | Postgres 1 GB, 10 connections, included | usage-based, billed separately | free Postgres expires after 30 days; paid tiers |
| Idle behaviour | scales to zero, first visit 10 to 30 s; keep-warm add-on € 9 | keeps running, you pay for the minutes | free tier sleeps after 15 minutes, wakes in about a minute |
| Container | 0.25 vCPU, 0.5 GiB, 10 GB traffic a month | you pick the size, you pay per second | fixed instance sizes |
| Domain, email, invoice | included, Dutch invoice, iDEAL or SEPA | own domain, dollar invoice | own domain, dollar invoice |
| Region | Amsterdam, database Dublin | several, including EU | several, including Frankfurt |

Where Railway and Render are better: any language, not just Node; more instance sizes on the menu; background workers and cron as first-class services; and a bill that scales down to nearly nothing for a toy project. Where we are better: a price you know in advance, and the domain, email and backups on the same invoice.

The deploy is one workflow file; the image is built on GitHub, your app gets `DATABASE_URL` and listens on `PORT`:

```yaml
- uses: dorelli-cloud/cli/.github/actions/dorelli-deploy@v1
  with:
    plan: app
    email: you@example.com
```

The full file is in [Deploy an app with a database](/docs/deploy/app). The first 14 days are free.

### Not for

Apps in Python, Go, Ruby or PHP; apps that need more than 1 GB of data or 10 database connections; apps with background workers or queues as separate services. Those are a better fit for Railway, Render, or our [Platform plan](/docs/plans/usage) once it has the building block you need.

## Why can my site not send email?
<!-- http://localhost:3000/docs/questions/site-cannot-send-email · checked 2026-09-22 · evidence: app/api/forms/route.ts, lib/formulieren.ts, content/kb/email/own-domain.md, content/talen/en.json -->

Because a website runs in the visitor's browser, and a browser cannot send email. The AI that built your site probably wrote a form that "sends" a message, but without a server behind it nothing leaves the page. On Dorelli Cloud that server is our contact form module: point the form at it and the message lands in your inbox, with a bot check, and we keep no copy of the content. It is included in the Website plan at € 10 a month.

| What you want | What works |
|---|---|
| A contact form that reaches you | our form module: the form posts to `/api/forms` on your own site address |
| Mail to `info@yourdomain.nl` | included: we forward it to an inbox you already use |
| Your site sends mail as `you@yourdomain.nl` | a static site cannot; an app can, through a mail service with SPF and DKIM set on your domain |
| Newsletters or bulk mail | not here; use a mail service and let it send from a subdomain |

The form module needs only a normal HTML form on your site that posts to its own address, so there is no key to hide in the page. Three fields are required: a name, an email address and a message.

```html
<form method="post" action="/api/forms">
  <input name="name" required>
  <input name="email" type="email" required>
  <textarea name="message" required></textarea>
  <button>Send</button>
</form>
```

Submissions go to the email address you registered the site with, and a visitor who sends too much in a short time is slowed down. Counts per day are in your portal; the contents are not stored. Our templates come with this form built in.

An app on the App plan can send mail itself, with a mail service of your choice. Put its key in the environment variables in your portal, and use a sending address on your own domain: SPF, DKIM and DMARC for that domain are set by us when the domain is connected, see [Email on your own domain](/docs/email/own-domain).

### Not for

A mailbox with its own login or webmail (we forward, we do not store mail), and mass mailings. Not for a form that must save submissions in a database; that is an app, not a static site.

## Is my project a static site or an app?
<!-- http://localhost:3000/docs/questions/static-site-or-app · checked 2026-09-22 · evidence: lib/trial-sites.ts, content/kb/deploy/limits.md, lib/config.ts, lib/bundelgrenzen.ts -->

Ask one question: does something have to run on a server after the page is loaded? If the answer is no, it is a static site and belongs on the Website plan for € 10 a month. If there are logins, orders, a database, an API route or server components, it is an app and belongs on the App plan for € 15. The price difference is one container and one Postgres database.

| Sign | Static site (Website, € 10) | App (App, € 15) |
|---|---|---|
| Build output | a folder with `index.html`, CSS, images, browser JavaScript | a server that starts with `npm start` and listens on a port |
| Data | none, or in a service you already use (Supabase, Firebase, Airtable) | your own Postgres database, included |
| Framework hints | plain HTML, Vite, Astro, Next.js with `output: "export"` | Next.js with API routes or server components, Express, Nest, Remix |
| Forms | our contact form module sends submissions to your inbox | your own code handles them |
| Deploy | paste, upload, or one command | a GitHub workflow that builds the image |
| Files that give it away | nothing ends in `.php`, `.py` or reads `process.env` | a `server.js`, an `api/` folder, a `Dockerfile` |

A quick test from the project folder. If this produces a folder you can open in the browser, you have a static site:

```bash
npm run build
npx github:dorelli-cloud/cli deploy dist --email you@example.com
```

Does the upload get refused with a message about server-side code? Then it is an app, and the route is [Deploy an app with a database](/docs/deploy/app).

Common case: Lovable, v0 and Bolt often generate a front end plus Supabase. That front end is static; the database already lives at Supabase. Website plan, € 10. Only when the tool generated its own backend with its own tables do you need the App plan.

### Not for

Static sites above 50 MB or 500 files, and sites with `.php`, `.py` or `.env` files in them; those are refused with an explanation. Apps in a language other than Node, and apps that need more than 1 GB of data or 10 database connections; those are questions for the Platform plan or another host.

## How do I deploy a v0 project with a database?
<!-- http://localhost:3000/docs/questions/v0-project-database · checked 2026-09-22 · evidence: content/kb/deploy/v0-bolt.md, content/kb/deploy/app.md, lib/config.ts, lib/bundelgrenzen.ts -->

It depends on what v0 built. A v0 project is a Next.js app; if it has API routes, server components or its own data, it belongs on our App plan (€ 15 a month) with a Postgres database included. If it is only a front end, export it as static files and host it on the Website plan for € 10. Both start with 14 free days.

| Your v0 project | Plan | How |
|---|---|---|
| Front end only, data lives elsewhere or nowhere | Website, € 10 | `output: "export"` in `next.config`, build, publish the `out` folder |
| API routes, server actions, own database | App, € 15 | GitHub workflow, own container and Postgres in the EU |

The static route, from your project folder:

```bash
npm run build
npx github:dorelli-cloud/cli deploy out --email you@example.com
```

The app route is one workflow file in your repository. The image is built on GitHub; your app gets `DATABASE_URL` (Postgres, 1 GB, 10 connections) and listens on `PORT`. The file is in [Deploy an app with a database](/docs/deploy/app).

```yaml
- uses: dorelli-cloud/cli/.github/actions/dorelli-deploy@v1
  with:
    plan: app
    email: you@example.com
```

Did v0 generate code for Vercel Postgres or Neon? Replace the client with a plain `pg` or Prisma connection on `DATABASE_URL`; the SQL stays the same.

### Not for

A project that needs Vercel-only features such as Edge Middleware, ISR on the edge or Vercel Blob; those have no equivalent here. An app above 1 GB of data, 10 connections or 10 GB of traffic a month is a Platform plan question, where you pay for what you use.

## Backups and security
<!-- http://localhost:3000/docs/security/backups · checked 2026-09-14 · evidence: lib/backup.ts, BACKUP.md, next.config.ts (beveiligingsheaders), lib/auth.ts -->

**Backups.** The platform database is copied every night to storage in the Netherlands, and those copies are kept for ninety days. Each copy is checked after it is made: if it is missing or suspiciously small, that is reported the same night instead of quietly rotting for three months. Restoring has been tested, not just described.

For your own site, the files you published are the backup: you keep the source in your own tool or repository, and republishing takes seconds. For an app with a database, the database is included in the nightly copy.

**Encryption.** Everything runs over HTTPS with a certificate we arrange and renew automatically. Traffic to the platform and to your own domain is never plain. Stored data sits on encrypted disks.

**Access.** Only the owner has administrative access to the platform. Passwords are stored as hashes, never readable, and login attempts are throttled after five failures from the same address.

**Headers.** Every page is served with the usual protective headers: no content sniffing, no embedding in a frame elsewhere, a strict referrer policy, and HTTP Strict Transport Security.

**What you are responsible for.** The content of your own site and app, and the strength of your own password. If your app talks to a database, keep secrets out of the source and put them in the environment variables in the portal.

**Found something wrong?** Report it through support with the word security in the subject. We look at it the same working day, and we never hold it against the reporter.

## Support for agents and AI tools: llms.txt, OpenAPI, error codes
<!-- http://localhost:3000/docs/support/agents · checked 2026-09-13 · evidence: app/llms.txt/route.ts, app/openapi.json/route.ts, lib/fouten.ts -->

Are you an AI agent, or building one? These are the machine-readable entry points:

- `/llms.txt`: the short version of how to publish here, with exact commands. Per language: `/nl/llms.txt`, `/de/llms.txt`, and so on.
- `/llms-full.txt`: this whole documentation as one plain-text file.
- `/openapi.json`: the deploy API. `POST /api/deploy` publishes, `PUT /api/deploy/{id}` updates, `GET /api/deploy/{id}` shows status.
- Every article in these docs is also available as raw markdown: append `.md` to its address, for example `/docs/deploy/cli.md`. The index is at `/docs/index.json`.
- Every error the API returns has a `code`, a readable `bericht` and a `help` URL that points to the article about that error, see [Error codes](/docs/errors/E-600).
- A question for support can be filed with your deploy token: `POST /api/support/tickets` with `Authorization: Bearer <deploy_token>` and `{ "onderwerp": "...", "bericht": "..." }`.

Rules that keep everyone safe: use the real email address of the user (the management link goes there), never show the contents of `.dorelli.json`, and if a deploy is blocked (HTTP 422, error `blocked`) tell the user honestly instead of trying to get around it.

## How support works: tickets, email, AI and a human within one business day
<!-- http://localhost:3000/docs/support/how-it-works · checked 2026-09-13 · evidence: lib/support.ts, lib/support-inbound.ts, app/support/page.tsx -->

Every question becomes a ticket, whichever way it comes in: the form at `/support`, an email to support@dorelli.cloud, your portal, or the API. You get a confirmation with a ticket number like `#123` right away.

**Replying by email works.** Every mail we send about a ticket has the number in the subject; reply to it and your message lands in the same ticket. Replying to a closed ticket reopens it.

**Who answers:** our AI assistant answers simple questions that are fully covered by this documentation and marks its replies as AI. Anything about money, legal matters, abuse or a complaint goes to a human. A human replies within one business day in any case.

**Closing and rating:** we close a ticket when it is solved, or automatically after seven days without a reply from you. You then get a one-click rating link; the score helps us improve.

**No account needed.** Own a trial site? Use the management link from your email to open a ticket that is linked to that site. Signed in? Your portal shows every ticket on your email address, also the ones you sent by email.

## What happens after the 14-day trial
<!-- http://localhost:3000/docs/trial/after-14-days · checked 2026-09-13 · evidence: lib/trial-onderhoud.ts, lib/mail.ts, HOSTING-FUNNEL.md -->

A trial site stays on `yourname.dorelli.cloud` for 14 days, without an account, and is not indexed by search engines (noindex).

On day 12 you get one email: keep it? Pay € 10 via iDEAL (€ 15 for an app) from your management link and we move the site to your own domain with email, SSL, backups and monitoring. That first payment also sets up the monthly direct debit and creates your portal account, see [Your portal account](/docs/account/portal).

If you do nothing, the trial site goes offline after 14 days and the files are cleaned up. The registration (email address, subdomain name) is deleted six months later. You do not have to cancel anything.

Want the site gone earlier? One email to support is enough.

## What gets scanned on upload, and where it goes
<!-- http://localhost:3000/docs/trial/moderation · checked 2026-09-13 · evidence: lib/moderation.ts, app/privacy/page.tsx -->

Before a trial site is served for the first time we automatically check its visible text for abuse: phishing, imitation of banks or brands, scams, malware, illegal content. We put your site under our own domain, so we want to know what will be there.

Only the visible text goes out, at most around 12,000 characters, no images, code or file names. It is sent to Anthropic, which does not train on it and deletes it within 30 days. A normal site of a hairdresser, a practice or a shop passes; so do empty pages, test text and half-built sites.

If a site is blocked you get an HTTP 422 with error `blocked` and a short reason. A person looks at every block. Think it is a mistake? Reply to the email or open a ticket at `/support` and we check it by hand. Trying to get around the check is not an option; it is fail-closed by design.

The same check runs on the start page of an app after its first start.

## Error codes

- E-600 (HTTP 400): Invalid input.
- E-601 (HTTP 400): Enter a valid email address.
- E-602 (HTTP 400): Subject and message are required.
- E-603 (HTTP 400): The bot check failed. Please try again.
- E-604 (HTTP 429): Too many requests. Try again in an hour.
- E-605 (HTTP 401): The token is invalid or expired.
- E-606 (HTTP 404): Ticket not found.
- E-607 (HTTP 400): Unknown category.
- E-500 (HTTP 401): No agent key was sent.
- E-501 (HTTP 401): The agent key is invalid, expired or revoked.
- E-502 (HTTP 403): This key lacks the right for this action.
- E-503 (HTTP 409): The maximum number of agent keys for this plan is reached.
- E-504 (HTTP 429): The daily deploy limit for agents on this plan is reached.
- E-505 (HTTP 503): Agent keys are temporarily disabled.
- E-506 (HTTP 400): Unknown right or invalid input.