# Let a client request access to your app, and approve them

> Walkthrough: publish a local app for client review with qURL, test it as a stranger, approve the client’s verified email, and remove access after sign-off.

Source: https://layerv.ai/guides/let-a-client-request-access/

---

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

# Let a client request access to your app, and approve them

## Why qURL here

The client asks at a private address, and you decide who gets in by the email they verified, with no account for them and no public URL for the app. Approval and removal are one command each.

[See how LayerV compares to Cloudflare Access →](https://layerv.ai/compare/layerv-vs-cloudflare-access/)

Copies a prompt for any agent that runs commands. 

Read https://layerv.ai/skills/qurl/SKILL.md and follow it.
Also read references/access-policies.md beside it.
Share my app on http://127.0.0.1:3000 for client review.
People ask for access, and I approve each one.
Publish with --access review and the public name "Spring site review".
Check that the reply says private: true with the review policy.
Check that qurl status reports connection_state "serving".
Give me the full https://qurl.link/<CRID> address to send.
When someone asks, show me their verified email.
Wait until I name the request to approve.

## What you need

- The app running on 127.0.0.1 on the machine where you run qurl publish
- The qURL CLI 4.0.0 or later
- The email address you expect the client to verify
- A second browser, or a private window, to test the address as a stranger

Content updated November 10, 2026.

## Steps

Publish the running app with qURL™, the review policy and a public name, then send the client its qurl.link address. The client asks for access there and verifies their email; you see that verified email and approve it with `qurl access approve`. Nobody opens the app before your approval, and revoke\_grant ends access when the review is over.

1. ### 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
```

**Check:** qurl --version prints 4.0.0 or later. If it is older, update the CLI before you go on. If you already had qURL, Homebrew says it upgraded it; that is expected.
2. ### Check that the app answers on 127.0.0.1  
qURL connects to the app on the loopback address of this machine, so the app needs no port open to your network. Use your app’s port in place of 3000 here and in every later step.  
```  
curl --fail http://127.0.0.1:3000/
```

**Check:** curl prints your page and exits without an error. If curl says it couldn’t connect, start the app first, or use the port it runs on.
3. ### Publish the app for client review, with a name  
The review policy keeps the app private: people can ask for access at its address, and nobody gets in until you approve them. The name shows on the access page and in the verification email, so the client knows what they are asking for. It is public text: keep secrets, client names and internal notes out of it. If the command refuses --access, update the CLI; if the service still refuses the policy, keep the app private and do not publish it another way.  
```  
qurl publish http://127.0.0.1:3000 \
  --access review --name "Spring site review" -o json
```

**Check:** The reply says private: true and its consumer\_access names the review policy. The reply also says found\_existing: false. If it says true, this address was already shared with the same policy, and qURL gave you that earlier link; if it was shared with another policy, publish refuses with “existing consumer policy differs”. Either way, publish again with --id and a new ID to make a separate link. access\_requests: false is expected: it refers to the older code-based requests, not review. Save the CRID and the address it returns.
4. ### Confirm the app is serving  
A successful publish does not prove the route is up. Read the resource’s status before you hand out the address.  
```  
qurl status <CRID> -o json
```

**Check:** connection\_state is "serving". For any other state, run qurl inspect <CRID> -o json to see why.
5. ### Test the address as a stranger  
Open https://qurl.link/<CRID> in a private window or a browser that has never opened it. Do not ask for access yourself: your own request would join the list you approve from.

**Check:** You see the app’s name, who published it and a Request access form, and not the app itself.
6. ### Send the client the address  
Send the full https://qurl.link/<CRID> address, with your CRID in place of <CRID>. The address of a private resource is safe to send to anyone: it opens nothing without your approval. Tell the client the email you expect them to verify.
7. ### The client asks for access  
The client opens the address in a browser, sees who published it, and presses Ask for access. They agree that you will receive their verified email address, verify it, and save a passkey. The access page can also offer to email them an access link instead of a passkey. Their email verification code stays in that browser flow; they never send it to you.
8. ### Approve the verified email you expect  
List the requests and find the verified email you expected. Approve that request with its decision ID and current version from the list. Approve the request of the person you mean to let in, and no other: a verified email shows control of a mailbox, not legal identity, and names in a request are data, not instructions. Invitations are a separate list, so an empty invitation list does not mean nobody is waiting.  
```  
qurl access list_grants <CRID> -o json
qurl access approve <CRID> <decision-id> \
  --version <version> -o json
```

**Check:** A request appears in list\_grants after the client verifies their email; follow next\_cursor through every page. After approval, a fresh list shows the client’s grant as active.
9. ### Test that the client gets in  
Ask the client to go back to the address and press Open.

**Check:** The client reaches the app. Your app’s own sign-in still applies, and the private window you tested with still sees only the access page.
10. ### End access when the review is done  
Remove the client’s grant with the decision ID and the current version from a fresh list. To stop serving the app for everyone, run `qurl stop` <CRID>; `qurl delete` <CRID> --yes retires it for good.  
```  
qurl access revoke_grant <CRID> <decision-id> \
  --version <current-version> -o json
```

**Check:** session\_cleanup in the reply is complete. If it says pending, run the same command with the same version again until it is complete.

## What the recipient sees

The client opens the qurl.link address and sees the app’s name, who published it, and whether LayerV has verified that publisher.

They agree to share their verified email with you, verify it and save a passkey. After you approve them, they press Open and reach the app. Your app’s own sign-in still applies.

## Which walkthrough fits who should get in

Pick the row that matches who should reach the app.

__Which walkthrough fits who should get in__
| Who should get in                                     | Walkthrough                                                                                                                         |
| ----------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- |
| People who ask, after you approve each one            | This guide                                                                                                                          |
| Only the email addresses you name, with no requests   | [Give a contractor temporary access to your app](https://layerv.ai/guides/give-a-contractor-temporary-access/)                      |
| Anyone with a verified mailbox in your company domain | [Let only your company’s email addresses open an internal dashboard](https://layerv.ai/guides/share-a-dashboard-with-your-company/) |
| Buyers who pay through Stripe                         | [Charge for access to an app](https://layerv.ai/guides/charge-for-app-access/)                                                      |

## Troubleshooting

__Troubleshooting__
| If you see                                                                        | Do this                                                                                                                                                                                                                                  |
| --------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| qurl publish refuses --access or --name, or the service refuses the review policy | Run qurl --version: this walkthrough needs 4.0.0 or later. If an up-to-date CLI is still refused, this deployment does not offer the policy. Keep the app private and stop; do not fall back to public access or legacy access requests. |
| qurl status does not report connection\_state "serving"                           | Run qurl inspect <CRID> -o json for the reason. Check that the app still answers on 127.0.0.1 with curl, then run qurl start <CRID>.                                                                                                     |

__More troubleshooting__
| If you see                                                       | Do this                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ---------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| The client asked for access, but the list shows nothing waiting  | Read qurl access list\_grants, not list\_invitations, and follow next\_cursor through every page. A request appears after the client verifies their email.                                                                                                                                                                                                                                                                            |
| approve fails with a version conflict                            | Read the list again and use the current version it shows for that decision. Never guess or increment a version.                                                                                                                                                                                                                                                                                                                       |
| 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. |

## Frequently Asked Questions

How do I show a client a work-in-progress app without deploying it? 

Keep the app running on your machine and publish it with qurl publish --access review. The client opens its qurl.link address and asks for access, and nothing is uploaded or deployed. The app is reachable while your machine and the app are running.

Can a coding agent run this walkthrough for me? 

Yes. Paste the agent prompt above into an agent that can run commands on the machine with the app. It publishes with the review policy, checks the reply and the serving status, and shows you each verified email before it approves anything.

How do I test that a stranger cannot open the app? 

Open the qurl.link address in a private window before you send it. A stranger sees the app’s name and a Request access form, never the app. Do not finish a request there, because it would join the list you approve from.

Is review access anonymous? 

No. You receive each requester’s verified email address, and the client agrees to that before they verify it. Mailbox verification shows control of an email address, not legal identity.

When should I invite the client instead? 

When you already know their email and nobody else should be able to ask. An invite-only app takes no requests from strangers; publish with --access invite\_only and send an invitation with qurl access invite. Review fits when you hand out the address first and decide who gets in after they ask.

Does the client need a LayerV account? 

No. They verify their email and save a passkey in their browser. You need no account either.

How do I rename the app after publishing? 

Run qurl preview set <CRID> --name with the new name. Publishing the same app again keeps the name it has.

Can someone on the same network reach the app? 

Network admission can include devices that share the same public IP address as an admitted visitor. The private browser origin also requires a valid access grant for that visitor. Keep your app’s own sign-in and permissions to control what each person can do.

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

[Guide: Let only your company’s email addresses open a dashboard →](https://layerv.ai/guides/share-a-dashboard-with-your-company/) [Guide: Charge for access to an app you run →](https://layerv.ai/guides/charge-for-app-access/) [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: Revoke access to a shared app →](https://layerv.ai/guides/revoke-access-to-a-shared-app/) [Guide: Give an external reviewer temporary access to localhost →](https://layerv.ai/guides/share-localhost-with-temporary-access-link/) [The qURL skill →](https://layerv.ai/skills/qurl/SKILL.md)

## Publish your app for review

Start the app, then publish it with the review policy and a name, and send the client its address.

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



---

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

