A live website. A reusable API.
Discover the requests behind a page, shape the response, and publish a documented API your customers can use.
/catalog/itemsCaptured{ "id": "SKU-104",
"title": "Desk lamp",
"price": 45.00 }- Import from a live URLStart from the page you already use.
- Capture hidden XHR and GraphQL callsFind the data requests behind the page.
- Live testing and response mappingChoose what your API returns.
Turn page values into a product widget.
The source website is on the left. Choose which product values ApiClay should return, then see a separate app render only those fields on the right.
From your input to a useful result.
- Choose a sample input
- Apply the feature’s workflow
- Inspect the result
This example runs entirely in your browser with illustrative data. Use the real feature’s guide and listing to check supported inputs, access rules, and pricing.
Explore the example, then use the setup guide to try the real feature.
Project setup and what to check
Input: A source URL, the fields you need, and any query inputs your route should accept. Check how the page presents the data before choosing an extraction mode.
Workflow: Configure the website source and map the output. Use browser actions only when the workflow needs interaction, then test the route with representative inputs.
Result: A published API contract consumers can inspect and test in its listing. Your frontend can consume structured fields without implementing the extraction workflow itself.
Test missing values and layout changes. Revisit mappings when the source changes and monitor the published response if freshness matters.
From a live page to a documented contract.
Discover the request. Choose the fields. Publish a reusable API.
- 1
Import the page
Inspect a live URL and review suggested route drafts.
- 2
Shape the response
Test the source and map the fields your customers need.
- 3
Publish your API
Set access, limits, and pricing after a private test.
Discover. Map. Publish.
Capture the background request, test it against your source, and expose the fields your consumers need.
- Live URL import creates editable route drafts.
- Test the actual response before choosing mapping paths.
- Keep credentials private and review the listing before publishing.
Illustrative catalog response. Captured requests and mapping paths vary by source; re-test when the upstream changes.
{
"items": [{
"sku": "SKU-104",
"name": "Desk lamp",
"price": 45.00,
"available": true
}]
}Public field ← Tested response path
id ← items[0].sku
title ← items[0].name
price ← items[0].price
in_stock ← items[0].availableFind the data behind the page
Capture background XHR and GraphQL requests as editable route drafts.
Keep one public contract
Map source responses into a consistent set of buyer-facing fields.
From a dynamic web page to a documented API contract
The data behind a modern page often arrives after the initial HTML, through JavaScript, search controls, or background requests. ApiClay's live URL import helps a publisher inspect that traffic and create editable API route drafts. You refine the request and response contract before making the route available to buyers.
This workflow is useful when you have permission to retrieve and productize the source data. It combines route configuration with browser execution, proxy policies, session handling, and API monetization. Once published, your application or buyer calls the documented ApiClay route rather than maintaining the page-specific execution steps in every client.
Discover background data requests
Live URL import opens a page in a cloud browser, scrolls to trigger content, probes available search and pagination controls, and captures JSON or GraphQL traffic into a HAR-style record.
How it works
The resulting drafts are a starting point: review the captured paths, required inputs, secrets, and output before publishing.
Choose static, JavaScript, or automatic execution
A simple source may work as a fast HTTP request.
How it works
A JavaScript-heavy page may need browser rendering. Auto mode can begin with static fetching and escalate when necessary. Explicit render settings let you balance source compatibility with the compute and proxy costs of a successful call.
Automate the interaction before extracting
Browser actions can navigate, fill inputs, click controls, wait for content, scroll, evaluate expressions, and intercept XHR.
How it works
Bind public request inputs into configured actions for a reusable search or lookup route. Keep private authentication values in server-side fields or reusable Vault blocks.
Return a stable shape to every buyer
Choose captured XHR JSON when the source already has a suitable structured response, or transform page content into JSON, Markdown, text, and other supported outputs.
How it works
Schema mapping exposes the selected fields through the route's public contract. Re-test when the upstream page changes; automation still depends on the source.
Where this fits into your work.
Product and stock feeds
Expose permitted catalog searches behind a documented route with a predictable price, availability, and identifier schema for downstream applications.
Searchable public directories
Bind a caller's query into a page search and return the matching data fields. Use limits and trials to control exploratory traffic.
Authorized portal data
Use session bootstrap or an owner-saved login profile for an authorized portal workflow. Buyers use the route contract rather than sharing the login session themselves.
Start with a focused test.
Use these steps to set up Website to API and review the result before making it part of a larger workflow.
Import a live website →- 1
Import the live page
Open Publisher Studio and choose Import from Live URL. Provide the page and proxy configuration so ApiClay can inspect browser activity and suggest route drafts.
- 2
Test and shape the response
Review captured requests, mark credentials private, and run a live route test. Use the response explorer to map the fields buyers should receive.
- 3
Publish the contract
Start in a private sandbox, configure usage limits and pricing, then submit a public listing when the route is ready for marketplace discovery.
Understand each workflow’s cost.
Match the feature’s limits and billing model to the work you want to run.
Explore API listings →Publishers configure route prices and choose a proxy policy. Successful browser execution, verified CAPTCHA solves, or metered proxy traffic can affect request economics; review the complete cost before setting a price.
ApiClay applies a minimum price guard for vendor-paid platform proxies based on configured bandwidth caps. Failed calls follow refund rules, and failed platform-proxy bandwidth is absorbed by ApiClay under the documented policy.
Open an API listing for its Reference, Playground, and Pricing. Check the selected route’s allowances and applicable infrastructure charges before increasing usage.
FAQs
Is this different from the URL extraction API?
Yes. Direct extraction accepts a URL for immediate processing. Website-to-API is a publisher workflow for creating a reusable route with documented inputs, response mapping, access rules, and optional marketplace sales.
Does live URL import publish automatically?
No. It produces editable route drafts. Review inputs and secrets, configure policy and pricing, and test the route before publishing.
Can I use data behind a login?
For authorized workflows, session bootstrap and persistent profiles can supply the required session state. You remain responsible for the source permissions and for keeping stored login credentials and profiles restricted.
Will a website API keep working after the source changes?
It depends on the change. Background endpoints, selectors, and login behavior can change upstream. Use live testing and logs to diagnose changes and update the route when required.
Turn your next source into an API.
Start with a live URL. Build a contract your customers can use.