Netlify Drop vs Birta: What an Anonymous Drop Actually Gives You

The short answer

Two routes, one result. What separates them starts after the address exists.

Netlify Drop is a single gesture. Drag a folder into a browser window, no account, no setup, and there is a live URL a few seconds later. On Birta the same folder goes up too, just without the dragging: you point the agent you already work in at it. Claude Code, Cursor, Codex and Claude Cowork all read files off your disk already, so the agent picks the folder up and publishes it through its Birta connection. One sentence instead of one drag.

Where the routes actually part company is documented on Netlify's own site. The Drop quickstart, in a section headed "Is your project public?", says this:

If you drop without signing in, your project URL is protected with a temporary password until you claim it.

So the live URL is real, but it is not a link you can simply send to somebody. Most write-ups of Netlify Drop still describe the older behaviour, where the address came back public and claiming it was only about keeping the site. Read at the source on 5 September 2026, that isn't where it ends any more.

So the choice lands on the week after. Who makes the next change, whether the person you showed it to can say what's wrong with it, and whether a bad publish can be put back. Drop gets a folder to an address and stops there, which is exactly its appeal.

One thing this page will not claim: that Birta is the side with an agent connection. Netlify runs its own, and a Claude user can now send a design to it without opening a browser tab.

The question worth asking is how far one connection carries. Netlify's reaches a lot, and it stops short of the three things a bad publish needs: it hands an agent no list of what went out before, no way to put an earlier deploy back, and no domain. Netlify is the one saying so, in the source it publishes itself. One Birta connection opens a draft, hands back that version's own permanent address, publishes it, lists what came before, puts an earlier version live again, and reads the remarks somebody left on the page. That has its own section below.

What you get when you drop without signing in

Three things are true at once, and they get blurred together a lot.

The deploy itself works. Your files go up as they are. Netlify's create-deploys documentation puts it plainly: "If you drop a project without being logged in, Netlify publishes the files as-is." Note the "as-is". The framework detection and the build that Netlify runs for you only happen when you're signed in. Drop an unbuilt project anonymously and you get the unbuilt project.

The address is password-protected, per the quote above. Somebody opening it needs the password from you, which for a lot of "here, look at this" moments is the whole friction you were trying to avoid.

And claiming it is a fork, not a finish line. Netlify's quickstart continues: "After you claim it by logging in or signing up, the outcome depends on your plan." On the Credit-based plans, if your team has private by default switched on, the project stays private until you deliberately make it public, and whether that default is already on "depends on when your team was created". On a Legacy plan the project is public once claimed. Both branches are documented, and which one you land on turns on your own team rather than on anything you can check from outside.

There's also a practical ceiling worth knowing before you drag anything large. Netlify's troubleshooting notes say deploys under 50 MB work best and that individual files over 10 MB may cause the deploy to get stuck.

How the same folder goes up on Birta

You don't upload anything here, and that is the design rather than a missing feature. Birta doesn't read folders off your disk, doesn't convert file formats, and isn't going to, because the agent sitting in front of it does both already. Birta's job starts at the address.

What you say is roughly "publish this folder to Birta". The agent opens a draft, writes the files into it, confirms index.html is at the root, and publishes. The mechanics have their own page, including which of your files actually reach the site and what to do when a folder isn't a website yet, so read the folder-publishing guide rather than a summary of it here.

So "I have a folder and I want a live address" is closed on both sides. The gesture differs, and so does everything after it: the version, the review, the way back.

What each agent connection reaches

Netlify has an agent connector, so "an assistant can publish here" separates nothing. Netlify documents the server at netlify-mcp.netlify.app/mcp, with npx -y @netlify/mcp as the local option, and its Claude setup guide walks through connecting it from Claude's own connector list. There is a shorter route as well. Netlify built a destination into Claude Design, announced on 7 September 2026, so a design goes live from the Share menu and re-sending the same project updates the same site instead of making a new one. It wants a connected Netlify account, which is the one thing the drop zone doesn't.

What differs is where each connection stops, and on this one Netlify has already written the answer down. Its published tool source opens with a map of the ground the connector covers, finished items ticked off and unfinished ones left blank. Deploy rollback is blank. So is choosing which deploy goes live. So are domains.

Read on 7 September 2026, the tools match the map. Nothing in the set lists a project's deploy history, nothing publishes an earlier deploy, and nothing connects a domain. Both of the tools that read a deploy want a specific deploy id handed to them, so an agent has to already know the id of the thing it is looking for.

What the connection does cover is broad and genuinely useful: users, teams, projects, deploys and extensions. Create a project, start a deploy, read a deploy, list and rename projects, set environment variables and visitor access controls, read forms and their submissions, install an extension.

And deploy history and rollback are real on Netlify. They are just in the dashboard rather than in what the connector hands an agent, so the undo is available to you and not to the thing that published the site.

Birta went the other way round. The connection is how the product is used, not a second door onto a panel, so one connection carries the week: open a draft from a stored version, write files into it, publish it and get that version's own address back, list what was published before, put an earlier version live again, read the remarks somebody left on a version, connect a domain, read leads.

The gap isn't Netlify's alone. Of the hosts this site compares Birta with, none hands an agent a version list and a rollback. Netlify is only the clearest case, because it is the one that marks the work as not done in public.

What Drop keeps, honestly

Zero setup, and no account whatsoever. That is Drop's real advantage and it survives everything above. Birta wants an account and a project before anything happens, and if you've never connected an agent to it there is a first-time setup to get through. For a file somebody asked to see in the next two minutes, that cost is the whole story.

Three more rows go to Netlify on the free plan. Birta's free plan connects no custom domain at all, not one, and the first arrives on Solo at $12 a month. It puts a "made in Birta" mark in the corner of every published page, fixed there as an overlay, with no setting on the free plan that turns it off. Netlify now badges new free projects too, on anything created on or after 19 August 2026, but theirs is a per-project switch you can flip. Ours isn't. And the free plan reads the contents of 10 leads per site per month.

One more row goes to Netlify and it isn't a free-plan quirk. Netlify versions every deploy, lets you browse any deploy you have ever made, and puts an earlier one live again from a Publish Deploy button with no rebuild. Their own documentation calls rollbacks instantaneous. The catch is retention rather than capability: Netlify deletes deploys after 30 days on Free and Standard plans and 90 days on paid ones. Birta keeps the last 10 versions with no clock on them.

Those rows are real and they stay real. What none of them covers is who makes the next change to the page, which is where the rest of this goes.

Showing it to someone, then changing it

This is where the two shapes invert, and it is the part most comparisons in this category skip entirely.

Netlify Drop moves the cost onto the viewer. You pay nothing to publish, and the person you're showing it to needs a password from you. Birta moves the cost the other way: you pay the account and the project up front, and then the viewer needs nothing at all.

Every version on Birta gets its own permanent address, handed back when the agent opens a draft and again when it publishes. It is separate from the site's own address and it keeps working after publication, so it stays the page you send when you want an opinion rather than a launch.

By default anyone holding that address opens it without an account. The browser passes a signed handoff in the background and the visitor gets a nickname, which is what signs their remarks. They then mark the remarks straight onto the page, attached to the element they're talking about, so "this heading" is a click rather than a paragraph of explanation.

Your agent reads them back. Birta's own instruction to the agent is that the owner "may mark remarks on the page", and that it should then read them, "make the changes in this same draft, and tell them to refresh the same page". Each thread comes back with a number, the page and the element it points at, whether it is open or resolved, and every message with its author and timestamp. Thread numbers are permanent, so "number four is still open" still means something next week.

One limit, stated plainly: the agent only reads. It cannot post a reply into a thread or mark one resolved, and an attempt to write is refused. Closing a thread is something you do in the browser. Everyone with access also gets an email digest of new remarks, sent roughly 15 minutes after the first one lands. None of this is gated by plan, and the walkthrough is in the versions and remarks guide.

Netlify has a review loop of its own, and it is a strong one. The Netlify Drawer puts comments, annotated screenshots and video recordings on a preview, syncs them to the pull request they belong to, and opens issues in GitHub, Jira or Linear. The Reviewer seat is free and unlimited.

Two things keep it away from the route this page is about. Netlify's documentation says reviewers "must be approved and log in to Netlify through the Netlify Drawer", so it is a free account rather than no account. And the Drawer runs on a Deploy Preview or a branch deploy only, with deploy permalinks explicitly unsupported, while a Deploy Preview comes from a connected Git repository or an agent run. A folder dragged into the drop zone has neither, so the drop route never reaches the Drawer.

Which leaves the same review round on Drop looking like this. You send the password, your client replies in chat that the second heading is wrong, you edit the folder, rebuild it, and drag it onto the deploy zone again. That loop is fine once. It is the second and tenth pass that decides which product you actually wanted.

Compare the work after the first upload

Netlify takes the entry gesture, the build, the domain, the badge, deploy retention on paid plans and anything needing a router. Birta takes the rows where one connection has to carry the work: the version the agent can put back, the remark a stranger can leave without an account. The two that settle most real cases sit near the middle: who makes the next update, and whether the person you sent the link to can tell you what's wrong with it.

Use Netlify Drop when...

Use it when the page genuinely doesn't need to outlive the moment. A one-off handoff, a demo you'll throw away on Friday, a file somebody asked to see. Drop is the shortest path from a folder to an address and adding an account to that is a step you don't need.

Use it when you want Netlify to build the thing for you. Sign in, drop an unbuilt project, and it detects the framework and runs the build. Birta has no build step of any kind, and that is a boundary rather than a gap being closed. On this side the building belongs to your agent.

Use it when you're already on Netlify. If your team, your domains, and your other sites live there, dragging one more folder into the same dashboard beats standing up an account somewhere else to save nothing.

Use it when the site belongs in a Git repository. That is the route that unlocks Deploy Previews and the Netlify Drawer, which is a richer review surface than ours: annotated screenshots, video, and comments that land in the pull request and in Jira or Linear. Drop is the wrong door to it, but if review is the job and your work already lives in a repo, Netlify is the better answer.

And use it if the site needs anything a static host can't serve. Functions, a form the platform handles, or the rewrite rule a single-page app needs so its router takes over on every path. Birta serves static files, deliberately, and that boundary isn't moving.

Birta fits better when...

Birta fits when the folder isn't the end of it. The client wants three changes, then two more, then the pricing updated in a month. Every one of those on Drop is another manual rebuild and another drag onto the deploy zone. On Birta it's a sentence to the agent that already has the source.

Choose it when somebody other than you has to look at the site before it counts. They get an address that opens with no account, they mark what's wrong where it's wrong, and your agent reads the list and fixes it in the same draft.

Choose it when a bad publish has to be reversible by whoever caused it. Netlify can undo a deploy too, and faster than we can describe, but the undo is a button in the dashboard and the person who broke the site is an agent that cannot reach it. On Birta the same conversation lists what was published before and puts it back with the original files. That matters more than it sounds when the thing publishing your site is working quickly.

Choose it when the page needs to collect something from the people who read it. The agent declares the form's fields, submissions land in the project's Forms tab, and everyone with access gets one email digest roughly 15 minutes after the first lead arrives.

And choose it when you want the site to stay up for free without a card, for as long as you want, across up to fifty projects. Anyone keeping a shelf of small client sites feels that row before any other.

The trade-off, restated so it isn't buried: a first-time setup instead of a drag, no custom domain on free, a badge you can't remove on free, 10 readable leads a month on free, no build step, and no way to take a payment from your site's visitors yet. Every one of those is a fact about the free plan or the product's static boundary. None of them changes who handles the next update, and that is the row this page keeps returning to.

If you're moving a dropped site over

This is short, because a static site is your own files and neither side holds them hostage.

1. Step 1Get the folder backUse the local folder you dropped. If you've lost it, download the deploy from the project's Deploys page in Netlify.
2. Step 2Hand it to your agentPoint the agent you already use at the folder and have it create a project and publish. The connection guides cover the tool-by-tool setup.
3. Step 3Check every page, then move the domainWalk the internal links and any form on the new address before repointing DNS. Repoint last, once the copy passes.

One thing won't travel: anything relying on Netlify's platform features, such as its own forms, functions or redirect rules. Those need rebuilding against what Birta actually offers, and for a form that means letting the agent declare it rather than porting the markup as-is.

The decision

Ask one question and most of this resolves. Does the thing you're publishing need to be alive next month?

If not, drop it. You'll have a URL before you've finished reading this sentence, and the password is a small tax on something you were going to throw away anyway. If you're still weighing hosts in general rather than this one, the wider list is over here, and the drag-and-drop comparison that's really about maintenance covers the ground this page deliberately skips.

If it does need to be alive next month, weigh the week after the gesture. Who makes the next change, whether they can undo it, and whether the person you send the link to has to ask you for anything.

The middle one is the row nobody in this category has closed. An agent can publish to most hosts now, several will let a stranger comment on a page, and none of those connections will hand the agent a version list and put an earlier publish back. Netlify says as much in its own repository. That is the row one Birta connection was built to carry, and it is the reason the same conversation that broke the site can fix it.

Frequently asked questions