Skip to main content
← All 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 →

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.

More

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 inWalkthrough
People who ask, after you approve each oneThis guide
Only the email addresses you name, with no requestsGive a contractor temporary access to your app
Anyone with a verified mailbox in your company domainLet only your company’s email addresses open an internal dashboard
Buyers who pay through StripeCharge for access to an app

Troubleshooting

Troubleshooting
If you seeDo this
qurl publish refuses --access or --name, or the service refuses the review policyRun 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>.
Show 3 more fixes
More troubleshooting
If you seeDo this
The client asked for access, but the list shows nothing waitingRead 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 conflictRead 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 connectionsStart 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.

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 →

Book a pilot

Tell us what to hide. We’ll scope a pilot.

Enterprise starts with a paid pilot on one application, typically 60 to 90 days, credited in full toward year one if you convert within 60 days. After that, an annual package sized to what you protect, not per seat.