# Give an external reviewer temporary access to localhost

> Give a reviewer temporary access to localhost: invite their email so only they get in, or send a one-time link. No account or VPN.

Source: https://layerv.ai/guides/share-localhost-with-temporary-access-link/

---

[← All guides](https://layerv.ai/guides/) 

# Give an external reviewer temporary access to localhost

## Why qURL here

An email invitation is the strongest way in: only the address you invite gets in, after verifying that mailbox and saving a passkey, with no LayerV account, and you revoke it the moment the review ends. For a single quick look, a one-time link opens once and expires on its own.

Copies a prompt for any agent that runs commands. 

## What you need

- The app running on this machine, listening on 127.0.0.1, ::1 or localhost
- The qURL CLI 3.4.1 or later
- For an email invitation: qurl 3.6.0 or later

Content updated November 3, 2026.

## Steps

Publish the app with qURL™ as invite-only and invite the reviewer’s email. Only that address can get in: the reviewer verifies their email and saves a passkey, with no account or install. Revoke their invitation when the review ends. For one quick look, send a one-time link from `qurl share` instead.

1. ### Choose how the reviewer gets in  
An invitation names the person: only the invited email address can get in, after proving they control that mailbox and saving a passkey. A one-time link from `qurl share` is a bearer link: it opens once, for whoever holds it, so send it straight to them. For a named reviewer, follow steps 3–5\. For one quick look, publish without --access in step 3 and use step 6 instead of steps 4 and 5\. Both paths end with step 7\. The table below the steps compares every way in.
2. ### Install the qURL CLI  
On macOS, install it with Homebrew. On Linux and Windows, download the package for your platform from the latest release; the CLI page lists each one. Nothing asks you to sign up.  
```  
brew install layervai/tap/qurl
qurl --version
```
3. ### Publish the app, invite-only  
The first publish creates this device’s identity, starts a background service that keeps serving after you close the terminal (while you stay logged in), and prints the app’s CRID, its stable ID. The Access row says who can open the app: a plain publish makes it private from qurl 3.4.1 on. `qurl share` turns the CRID into an access link, and the link is what you send. Publish the origin the app listens on: `qurl publish` refuses a path, a query or a fragment, so the reviewer starts at / and you tell them where to go from there. Check that the reply has private: true and the invite\_only policy, and keep the CRID it returns for the next steps.  
```  
qurl publish http://127.0.0.1:3000 --access invite_only -o json
```
4. ### Invite the reviewer  
qURL emails the invitation. The reviewer opens it in any browser, verifies their email and saves a passkey, then lands on your app. Strangers cannot ask for access, and the passkey brings the reviewer back until you remove them.  
```  
qurl access invite <CRID> --email reviewer@example.com -o json
```
5. ### Check that it is serving, and who is in  
`qurl status` shows the state you asked for and the state the service observes. The access listings show each invitation and who has access, so you never need to open anything yourself.  
```  
qurl status <CRID>
qurl access list_invitations <CRID> -o json
qurl access list_grants <CRID> -o json
```
6. ### For one quick look: send a one-time link  
Use this instead of steps 4 and 5, on an app published without --access. The link opens once. --ttl is how long it waits to be opened; without an account the most is 24 hours. --session-duration is how long the reviewer can work once it is open, 1 hour by default and 24 hours at most. Check that the expiry line says “single use”. Send it in a direct message, not a public channel: whoever opens it first uses it. Avoid email and apps that preview links, because a scanner that runs the page could use its one opening. Don’t open it yourself to check it, for the same reason.  
```  
qurl share <CRID> --ttl 4h --session-duration 2h
```
7. ### End access  
To remove one invited reviewer, revoke their invitation with `qurl access revoke`\_invitation, which also removes the access it granted; `qurl access --help` shows its arguments. `qurl restart` ends open sessions and keeps the app shared. `qurl stop` stops serving the app until `qurl start`. `qurl delete` asks you to confirm, then retires the app and every way in for good. When the review is over, stop or delete the app, because anything you later run on that port is open to whoever still has access.  
```  
qurl restart <CRID>   # end open sessions, keep sharing
qurl stop <CRID>      # stop serving; qurl start <CRID> resumes
qurl delete <CRID>    # permanent; asks you to confirm
```

## What the recipient sees

An invited reviewer opens the emailed invitation in any browser, verifies their email, saves a passkey and lands on your app, with no LayerV account or install.

Their passkey brings them back until you remove them. Your app’s own sign-in, if it has one, still applies. A one-time link opens straight to your app, once; opening it again shows “Access link invalid”.

## Every way in, and what each one checks

__Every way in, and what each one checks__
| Way in                      | How you grant it                                                                           | Who gets in                                                                                                                                                                                                  | Reviewer needs                                        | Ends when                                                                                                                                        |
| --------------------------- | ------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
| Email invitation            | qurl publish <app> --access invite\_only, then qurl access invite <CRID> --email <address> | A named recipient. Only the invited address can get in: the person proves they control that mailbox and saves a passkey. Strangers cannot ask for access. A verified mailbox is not proof of legal identity. | A browser and the invited mailbox. No LayerV account. | When you revoke their invitation, which also removes the access it granted, or delete the app.                                                   |
| Access requests you approve | qurl publish <app> --access review, then qurl access approve for each request              | People you approve. Anyone with the address can ask; they verify their email first, and nobody gets in until you approve that address.                                                                       | A browser and a mailbox. No LayerV account.           | When you revoke their access with qurl access, or delete the app.                                                                                |
| One-time access link        | qurl publish <app>, then qurl share <CRID> --ttl 4h --session-duration 2h                  | A bearer link. It opens once, for whoever holds it, so send it straight to the person.                                                                                                                       | A browser. No account and no install.                 | The link ends after one opening or at --ttl. The session it opened ends at --session-duration, or sooner if you restart, stop or delete the app. |

Sources: [Agent skill](https://layerv.ai/skills/qurl/SKILL.md) , [CLI README](https://github.com/layervai/qurl-integrations/blob/main/apps/cli/README.md).

## Link, session and path behaviour (qurl 3.6.1)

Checked on 2026-10-29\. Other LayerV pages link here for these answers.

__Link, session and path behaviour (qurl 3.6.1)__
| Topic                                 | Behaviour                                                                                                                                                                                                                                                                                                                                                                                       | Source          |
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------- |
| Your account                          | None. The first qurl publish creates a device identity. Without an account you get up to 3 active resources, with links that last up to 24 hours; a free account raises that to 10 resources and 30-day links.                                                                                                                                                                                  | Agent skill     |
| Reviewer’s account or install         | None. A one-time link needs only a browser. An invited reviewer needs the invited mailbox and a passkey.                                                                                                                                                                                                                                                                                        | Agent skill     |
| Use limit                             | A link from qurl share opens once. Check that the expiry line says “single use”, or single\_use is true in -o json. Through the API, a link can allow more sessions.                                                                                                                                                                                                                            | Our CLI tests   |
| Link lifetime (--ttl)                 | An unopened link lasts until --ttl. Without an account that is 24 hours by default and at most; with one, up to 30 days. The service may grant less than you ask, and the CLI says so on stderr. After that, the link shows “Access link invalid”.                                                                                                                                              | CLI README      |
| Session lifetime (--session-duration) | Starts when the link is opened: 1 hour by default, 24 hours at most. A link that expires does not end a session already open. When the session ends, new requests are refused and open streams and WebSockets are cancelled.                                                                                                                                                                    | API reference   |
| What a session lets in                | The browser that opened the link, for this one app. After a browser opens it, another browser on the same public IP cannot use its access. A script or agent that opens the link without a browser is admitted by its network address instead, which other devices on that public IP share until the session ends.                                                                              | Vibe coding FAQ |
| IP, country and user-agent rules      | Do not apply to links from qurl share. The API’s access\_policy is not evaluated on signed links, which is what qurl share issues.                                                                                                                                                                                                                                                              | API reference   |
| Paths                                 | qurl publish takes an origin such as http://127.0.0.1:3000, never a path, query or fragment. The reviewer lands on /, and during the session every path of the app answers. Through the API, a link’s target\_path opens that path and limits the session to it and the paths below it.                                                                                                         | API reference   |
| Your app’s own sign-in                | Still applies. qURL passes no identity or cookie of its own to your app. The browser opens its own ….qurl.site address, while the gateway forwards Host c-<id>.qurl.site to the app with X-Forwarded-For and the other forwarding headers. A browser-origin check needs the browser’s address; a Host check sees the c-….qurl.site hostname.                                                    | Our CLI tests   |
| Protocols                             | HTTP, WebSockets, Server-Sent Events and streamed responses pass through. No raw TCP, and not for webhook senders, which cannot open a link.                                                                                                                                                                                                                                                    | Our CLI tests   |
| Link previews and scanners            | A preview that only fetches the link never sees its secret, which follows the #. A scanner that opens it in a browser and runs its scripts can use the one opening.                                                                                                                                                                                                                             | Agent skill     |
| Checking who has access               | qurl access list\_invitations <CRID> and qurl access list\_grants <CRID> show who you invited and who has access. For one-time links, with an account and API key, GET /v1/resources/<CRID>/qurls shows each link’s status (active, consumed, expired or revoked) and use\_count, and GET /v1/resources/<CRID>/sessions lists open sessions.                                                    | API reference   |
| Ending access                         | qurl access revoke\_invitation removes one invited person. qurl restart <CRID> ends open sessions and keeps sharing. qurl stop <CRID> stops serving the app until qurl start. qurl delete <CRID> retires the app and every link for good. With an account, the API revokes one link or ends sessions.                                                                                           | CLI README      |
| Traffic and records                   | Your machine connects out; nothing listens for inbound connections. TLS ends at LayerV, which handles the decrypted traffic only to route it and keeps none of the content. LayerV sees which links were issued, opened, denied or revoked, and session metadata such as source IP. The API lists live sessions and webhooks report access events; audit export is part of the Enterprise plan. | Trust           |

Sources: [Our CLI tests](https://layerv.ai/research/qurl-behaviour/) , [API reference](https://layerv.ai/docs/qurls.md) , [CLI README](https://github.com/layervai/qurl-integrations/blob/main/apps/cli/README.md) , [Agent skill](https://layerv.ai/skills/qurl/SKILL.md) , [Trust](https://layerv.ai/trust/) , [Vibe coding FAQ](https://layerv.ai/vibe-coding/).

## Troubleshooting

__Troubleshooting__
| If you see                                                 | Do this                                                                                                                                                                                                  |
| ---------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The reviewer can’t find the invitation                     | Check qurl access list\_invitations <CRID> -o json for their address, ask them to look in spam, and send it again with qurl access resend.                                                               |
| A one-time link fails the first time the reviewer opens it | Someone or something opened it first, such as a scanner that runs pages, or it passed its --ttl. Run qurl share again and send the new link in a direct message; the app does not need publishing again. |

__More troubleshooting__
| If you see                                                                                                             | Do this                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ---------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The reviewer lands on the home page, not the page to review                                                            | The app opens at /. Tell the reviewer the path to open, or make / redirect there for the review. With an account, a link made through the API can carry a target\_path.                                                                                                                                                                                                                                                               |
| The reviewer is sent to http://localhost:3000                                                                          | The app built an absolute URL from a configured base address, so the browser went to the reviewer’s own machine. Use relative redirects for the review. A sign-in provider whose callback is registered for localhost has the same problem.                                                                                                                                                                                           |
| The page says “Blocked request. This host … is not allowed”                                                            | The dev server refused the qurl.site hostname. Allow it as the dev-server hostname guide shows for your framework, then reload.                                                                                                                                                                                                                                                                                                       |
| qurl publish says the local app is not accepting TCP connections                                                       | Start the app first and check that curl works on the same address. qurl publish connects to localhost as 127.0.0.1, so if your app listens only on IPv6 (on macOS or Linux, lsof -iTCP -sTCP:LISTEN -nP shows \[::1\]), publish 'http://\[::1\]:PORT' instead, or start the dev server with --host 127.0.0.1 and publish that address. Neither requires listening on your LAN. Keep the quotes: zsh treats the brackets as a pattern. |
| The recipient sees “Access link invalid”                                                                               | The link was already used or has expired. Run qurl share again and send the new link.                                                                                                                                                                                                                                                                                                                                                 |
| The recipient sees “Resource not found”                                                                                | The resource was deleted after the link was made. Publish the app again, then run qurl share and send the new link.                                                                                                                                                                                                                                                                                                                   |
| publish rejects http://127.0.0.1 with “only HTTPS URLs are allowed”, asks you to log in, or prints no Access: line     | Your qURL CLI is out of date. On macOS run brew update, then brew upgrade qurl; elsewhere install the latest release. After updating, qurl --version prints 3.4.1 or later, and every publish is private by default.                                                                                                                                                                                                                  |
| publish says this Linux session “can’t reach a systemd user manager”                                                   | You are in a container or sandbox without a user service manager. Run qurl publish with --foreground; sharing lasts as long as that process runs. [Container and CI setup →](https://layerv.ai/guides/share-from-a-container-or-ci/)                                                                                                                                                                                                  |
| publish says “Quota Exceeded” with “protected resource limit reached”, or “Your qURL account has reached a plan limit” | You can see this without an account: a device with no account can keep up to 3 active resources, with links that last up to 24 hours. Run qurl list --status active, then qurl delete <CRID> for any you no longer need (it asks you to confirm; --yes skips that). qurl stop keeps the resource, so it does not free a slot.                                                                                                         |

## Frequently Asked Questions

Does qURL check who the reviewer is, or is it a bearer link? 

An invitation names the person: only the invited email address can get in, after proving they control that mailbox and saving a passkey. A one-time link from qurl share is a bearer link: it opens once, for whoever holds it, so send it straight to them.

Does the reviewer need an account or anything installed? 

No. An invited reviewer needs only a browser, the invited mailbox and a passkey, with no LayerV account. A one-time link needs only a browser.

Does my app’s own login still apply? 

Yes. qURL decides who reaches the app; it does not sign anyone in. It sets no cookie and adds no identity to requests, so your app asks for its own login as usual. Give the reviewer an account with only the permissions the review needs.

What happens when access expires? 

An invited reviewer keeps access until you revoke their invitation or delete the app. An unopened one-time link stops working at its --ttl and shows “Access link invalid”. A session already open keeps going until its --session-duration ends; then new requests are refused and open streams and WebSockets are cancelled. To end a session sooner, run qurl restart <CRID>.

Can a link preview or security scanner use up a one-time link? 

A plain link preview cannot: the secret part of the link comes after the #, and browsers and HTTP clients never send that part to a server, so a preview bot that fetches the link gets only the opening page. A scanner that opens the link in a real browser and runs its scripts can use the one opening, and the reviewer then sees “Access link invalid”. Send the link in a direct message to the reviewer, never open it yourself, and if it was used up, run qurl share again: the app does not need to be published again.

Can I send the reviewer to a specific page? 

Tell them the page to open once they are in: qURL shares the whole app from its root, /. With an account, a link made through the API can carry a target\_path that opens that page and limits the session to it and the pages below it.

How do I see whether the reviewer got in? 

qurl access list\_invitations <CRID> shows each invitation, and qurl access list\_grants <CRID> shows who has access. For one-time links, with an account and API key, GET /v1/resources/<CRID>/qurls shows each link’s status (active, consumed, expired or revoked) and use\_count, and GET /v1/resources/<CRID>/sessions lists open sessions. Never open a one-time link yourself to check it.

Who else can reach my app while it’s shared? 

Only the people you let in. With an invitation, only the invited address gets in, with its own passkey, and strangers cannot ask for access. After a browser opens a one-time link, another browser on the same public IP cannot use its access; a script or agent that opens it without a browser is admitted by its network address instead. Keep your app’s own sign-in for anything sensitive.

Does my computer have to stay on? 

Yes. The app is served from your machine, so the machine and the app must be running and connected. The background service reconnects after sleep, but the app is unavailable while the machine is asleep.

## Related Resources

[Every way to share localhost, compared →](https://layerv.ai/compare/localhost-tunnels/) [Guide: Share a dev server with a client →](https://layerv.ai/guides/share-dev-server-with-client/) [Guide: Give a contractor temporary access →](https://layerv.ai/guides/give-a-contractor-temporary-access/) [Guide: Password-protect a local app you’re sharing →](https://layerv.ai/guides/password-protect-localhost/) [Guide: Revoke access to a shared app →](https://layerv.ai/guides/revoke-access-to-a-shared-app/) [Guide: Make a one-time link for a demo →](https://layerv.ai/guides/one-time-link-for-a-demo/) [Guide: Allow a tunnel’s hostname in your dev server →](https://layerv.ai/guides/allow-tunnel-hostname-in-dev-server/) [How we tested qURL →](https://layerv.ai/research/qurl-behaviour/) [What LayerV sees →](https://layerv.ai/trust/) [qURL API reference →](https://layerv.ai/docs/) [qURL CLI README ↗](https://github.com/layervai/qurl-integrations/blob/main/apps/cli/README.md)

## Publish your app now

Install the CLI, then run one command. No sign-up, no API key.

[Install the CLI →](https://layerv.ai/cli/)



---

*This markdown version is auto-generated from [https://layerv.ai/guides/share-localhost-with-temporary-access-link/](https://layerv.ai/guides/share-localhost-with-temporary-access-link/) for AI agents. Curated agent resources: [llms.txt](https://layerv.ai/llms.txt). For the full interactive experience, visit the HTML version.*

