Skip to content

Share and run a Replit project

Get a Replit project in front of someone three ways: a live app link they just click and use, an invite so they edit alongside you in the same browser tab in real time, or a Remix so they copy the whole thing into their own account to change. Everything runs in the browser — nobody installs anything.

Time: the share itself is one click. The catches: inviting people to edit live needs a paid plan (the free tier doesn't give collaboration seats), and a published free app goes down after 30 days. [confirmed] Last verified: 2026-06-07 · button names, the three privacy options, and plan limits come from docs.replit.com and replit.com/pricing. [confirmed]

Before you begin

  • A Replit account, signed in at replit.com, with the project open in the Project Editor (the in-browser workspace where you build). One account, ~3 min to make.
  • Know which of the three you want: a link to the running app (anyone clicks, no Replit account to view a public one), live co-editing (they need a Replit account and you need a paid seat), or a Remix (they need a Replit account, then own a copy).
  • For the live-edit path: a paid plan — Core ($20/mo) gives 5 collaborator seats, Pro ($95/mo) gives 15. The free Starter plan lists no collaboration seats. [confirmed]

New to Replit? Replit is its own web IDE — you do the clicking here, not your agent. Open replit.com, let its Agent build something ("build me a one-page event sign-up form"), and you'll land in the Project Editor that every step below acts on.

Pick your share — the one click for each

You're in the Project Editor. The two buttons that matter both sit in the top-right header: Publish (ship the running app to a link) and Invite (let people into the workspace). [confirmed]

This is what most people want: a URL that opens your working app in any browser.

  1. Click Publish (top-right of the Project Editor). [confirmed]
  2. In the Publish dialog, pick who can access from the dropdown: [confirmed]
    • Public — anyone with the URL uses it, no Replit account needed. The default.
    • Only you / Workspace only — visitors hit a Replit sign-in screen first; only people you've granted access get in. (In a solo workspace these two behave the same.)
    • Password-protected — anyone with the password gets in, account or not. Available on all plans. [confirmed]
  3. Click Publish. Replit runs Provision → Security Scan → Build → Bundle → Promote — a minute or two. [confirmed]
  4. Copy the .replit.app URL from the Publishing tab and send it. Re-publish anytime and the same URL serves the latest version — no new link to send. [confirmed]

The running app and the source code are two different shares. Publish hands over the live app at a URL. Invite (below) and Remix hand over the editable project itself. Sending the app link does not let someone edit your code.

2. Edit alongside you, live — Multiplayer

Several people in the same project at once, changes appearing as you all type — like a Google Doc for code. [confirmed]

  1. Click Invite (top-right header). [confirmed]
  2. Search the person by name or Replit username, or copy the invite link. [confirmed]
  3. Pick their role from the dropdown — edit access, or read-only (they watch and run, can't change anything). [confirmed]
  4. They open it in their browser and you're editing together. Seats are capped by plan: 5 on Core, 15 on Pro. [confirmed]

3. Copy it to their own account to change — Remix

A Remix is Replit's word for fork — a complete copy of your project (files, config, dependencies) in their account, theirs to change without touching your original. [confirmed]

  • Make it remixable: publish your app Public. From its cover page, anyone can hit Remix and get their own copy. [confirmed]
  • They already have access? Owners, collaborators, and viewers can Remix straight from the editor. [confirmed]
  • Their copy is independent — your later edits don't reach it, and theirs don't reach you. Right for "here's a starting point, make it yours"; wrong for "one shared version everyone edits" (that's Multiplayer, above).

Public vs private — who can see what

  • A workspace project is private by default — "only visible to people and groups you explicitly invite." Sharing publicly is a deliberate act: you Publish as Public. [confirmed]
  • Publishing Public exposes the running app to anyone with the link. Whether your source code is browsable depends on the app's own visibility — a public published app can be remixed from its cover page. [confirmed]
  • Private published apps (Only you / Workspace only / password) work on every plan, free included — visitors sign in through Replit (or enter the password) before they see anything. [confirmed]
  • Free tier, honestly: you can build, publish one app, and let people view or Remix it — all free. What you can't do free is invite people to edit live (no collaboration seats) or keep more than one published app running. [confirmed]

If it doesn't work

  • Invited someone but they can't edit → either their role is read-only (change it to edit access via Invite → their name → role dropdown), or you're on Starter with no collaboration seats — live co-editing needs Core or Pro. [confirmed]
  • The app link is dead after about a month → on the free Starter plan a published app goes down after 30 days. Re-publish it, or upgrade to Core for an always-available link. [confirmed]
  • First visitor waits a few seconds, then it loads → an Autoscale app goes idle after 15 minutes of no traffic and cold-starts on the next request. Normal; it's not broken, and you pay nothing while idle. [confirmed]
  • "Should I Invite them or send a Remix?" → Invite = one shared project you both edit (changes are shared instantly). Remix = they get a separate copy that drifts independently. Pick by whether you want one source of truth or a clean hand-off. [confirmed]
  • Recipient hits a Replit sign-in wall on a link you thought was open → the app was published Only you or Workspace only, not Public. Re-publish and set the access dropdown to Public (only Public skips the login). [confirmed]
  • They want it private but you're on the free plan → fine — private published apps are on all plans. Set the access dropdown to Only you, Workspace only, or turn on the password. The free-plan limit is on collaboration seats and number of published apps, not on privacy. [confirmed]

Prefer to do it all by hand?

That's the only path here — Replit is a web IDE, so every step is a click you make in the browser (your coding agent isn't the actor for this one):

  1. Link to the app: Project Editor → Publish (top-right) → set access (Public for no-login) → Publish → copy the .replit.app URL.
  2. Live co-editing: Invite (top-right) → search a username or copy the invite link → set their role → they open it. (Needs Core/Pro for the seats.)
  3. Remixable copy: Publish Public → recipients use Remix on the cover page, or Remix from the editor if they already have access.

Watch / read

  • Best written walkthrough: Replit's own Publish your app (the four-click Publish flow and the access dropdown) plus Private Deployments (the Public / Workspace only / Only you / password options) and Remix an app (the copy-to-your-account flow). These are the authoritative, current sources for every button name above. [confirmed]
  • Official video: Replit embeds a short "Publish your app on Replit" clip on the Publish your app doc — the safest video because it's Replit's own and tracks the current UI. [confirmed]
  • Community video — How to Invite Collaborators in Replit — Shortcut Academy, ~2:30 — okay start on the Invite-button flow. [unclear — YouTube transcripts couldn't be verified from this machine this session, and the channel auto-publishes "2026 Full Guide" walkthroughs; treat the title as the signal and trust the official docs above for exact steps]

Other ways to share

  • Just the finished thing, and you don't need Replit's editor? → Deploy a website (Vercel, Netlify, Cloudflare) gives a link with no sleep and no 30-day expiry, or a Claude Artifact opens a tool in any browser, no account.
  • People will build on the code on their own machines? → a GitHub repository hands over every file with full version history and a review-before-merge flow.
  • You'd rather hand over a recipe than a live project? → a reconstruction prompt — one block of text that rebuilds a close cousin, no account or seat on either side.

Sources

  • Publish your app — Replit Docs (the Publish button, the four-stage build, the access dropdown, re-publish to the same URL) — checked 2026-06-07
  • Private Deployments — Replit Docs (Public / Workspace only / Only you, password-protected on all plans, "available on all plans") — checked 2026-06-07
  • Project Visibility — Replit Docs (a project is "only visible to people and groups you explicitly invite"; publish public to share to anyone with the URL) — checked 2026-06-07
  • Remix an app — Replit Docs (a Remix is a new app copied from one you can access; Remix from the cover page or editor) — checked 2026-06-07
  • Multiplayer / Invite teammates — Replit Docs (the Invite button in the header, search by name/username, role dropdown, read-only vs edit) — checked 2026-06-07
  • Starter Plan — Replit Docs (one free published app, down after 30 days; collaboration seats and extra published apps require Core) — checked 2026-06-07
  • Pricing — Replit (Starter free; Core $20/mo, 5 collaborators; Pro $95/mo, 15 collaborators + 50 viewers) — checked 2026-06-07
  • Autoscale Deployments — Replit Docs (an Autoscale app goes idle after 15 minutes of inactivity and cold-starts on the next request) — checked 2026-06-07