Hide infrastructure
Make your API answer only to traffic you’ve verified
Let an agent reach a private API for one task without making that API a public endpoint. Publish once, keep its cryptographic identity, and issue signed access from your code.
Stop your API from answering strangers
A public API accepts connection attempts before its application checks the caller. That gives scanners a path to probe its routes. Private automation needs a way to create access for a task without exposing the origin to everyone.
| The usual fix | What to consider |
|---|---|
| Public API key check | Application authentication starts after the caller reaches the public endpoint. |
| Private network membership | Useful for ongoing connectivity; an agent task may need only one API for a bounded time. |
| Shared service credentials | A credential reused across jobs needs rotation and revocation planning. Give each task its own resource grant. |
Give the task a grant to the private API
Keep the origin private. LayerV verifies access before the protected origin connection opens; your app serves the authorized task.
# Install the latest CLI and run qurl login first. qurl publish http://127.0.0.1:8080 # Copy the CRID printed by publish. qurl share <CRID> --ttl 1h
Send the returned access link to the recipient. The CRID identifies the resource and does not grant access on its own.
Publish the app
Start the HTTP app on loopback on this host. Publish it with the qURL CLI and save its CRID. Close any separate public route.
Issue an access link
Use the CRID to issue a fresh signed access link for this task through the CLI, SDK, or API. Keep your app login for verified user identity.
Set the access window
Set link expiry and supported use limits. An open session has its own lifetime; revoke the link or delete the resource when access must end early.
What to install, and how someone gets in
Publish with
The qURL CLI, for an API you run yourself ↗Give access with
An access link issued with the CLI, SDKs, or API ↗- 01Install the qURL CLI and enroll this machine with qurl login
- 02Keep the app running on loopback and publish it with qurl publish http://127.0.0.1:8080
- 03Restrict any old public route and verify it no longer reaches the app directly
- 04Issue an access link with qurl share <CRID>, or use the API for additional policy controls
- 05Use qurl stop <CRID> to pause local serving, or qurl delete <CRID> to retire the resource
What the traffic you want looks like
Choose how to issue and open the access link.
A browser recipient
Open the link sent by the resource owner, then complete the application’s own sign-in if it requires one.
Your application
After your own authorization check, use an SDK or API call to issue a link with the required limits.
A machine or agent
Open the received link with the Go SDK EnterPortal flow, then use the returned handle to call the resource. A plain HTTP request to the share link does not perform this opening flow.
Serve real clients, ignore everyone else
Hidden until access is authorized
Keep the origin off the public internet. LayerV checks access before opening its connection to the app.
A stable name for every task
Reuse the CRID to issue new grants. The resource identity stays separate from its address and each access link.
Agent access without a browser
A compatible SDK verifies and opens the link, then the agent calls the private API through the returned session.
Controlled lifetimes
Set link expiry and use limits, with separate session-duration controls.
Built for
- Teams managing internal or partner APIs
- Organizations concerned about AI/LLM crawler abuse
- Companies with sensitive data behind API endpoints
- Teams building MCP servers or AI agent infrastructure
Questions
How do machines and AI agents access a hidden API?
Use the API or SDK to issue access links. Use the appropriate SDK link-opening flow for shared links; POST /v1/resolve redeems access tokens according to the API contract.
Does this replace API keys?
An access link controls entry to a published resource. Keep the application’s own authentication and API permissions when it needs them, and protect the credential used to issue links.
Do we need to change our API code?
You can publish a local HTTP API with the CLI. Integrating programmatic minting or headless access requires the documented client flow; a DNS change alone does not close an origin.
Can scanners and AI crawlers still enumerate our endpoints?
Without an access grant, scanners cannot reach the protected private API through LayerV to enumerate its routes. Close any separate public origin route. Authorized callers can still reach the routes the application exposes, so keep API permissions in place.