Your source. Your API. Your business.
Import a request, connect a datasource, and test the contract. Publish with documentation, access controls, and billing in one studio.
/catalog?sku=SKU-104{ "items": [{
"sku": "SKU-104",
"price": 45.00
}] }- cURL, Postman, OpenAPI and HAR importsBring the request you already have.
- Live response mappingChoose fields from a real test response.
- Private sandbox and encrypted draftsReview before you publish.
Turn an existing request into a route draft.
The request description is on the left. ApiClay imports it into a draft you can review on the right. Configure the remaining inputs and credentials, then test in the real studio before publishing.
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 working cURL request, Postman collection, OpenAPI document, or HAR capture. Identify the request inputs, useful output fields, and upstream credentials.
Workflow: Import the definition, review the generated configuration, map the response, and test it. Configure the listing and access rules before publishing.
Result: An API listing with its own reference, playground, and pricing. Buyers can evaluate the contract without receiving the upstream credentials.
Confirm secret handling, required parameters, error responses, and the published output. An import is a starting configuration that still needs review.
From your first request to a published API.
Import, test, and map your source in one focused workspace.
- 1
Import your source
Paste a request, connect data, or choose a recipe.
- 2
Test and map
Keep secrets private and select the public response fields.
- 3
Package and publish
Set access, trials, usage limits, and pricing.
Shape the response you actually tested.
Separate public inputs from private credentials, then map the live result into a clear buyer-facing contract.
- Imports include cURL, Postman, OpenAPI, and HAR.
- Click-to-Map uses fields from a real test response.
- The optional BYOK assistant is not required to publish.
The source URL and token are placeholders. A paste import parses configuration; a live test executes the request and may incur charges.
curl 'https://api.example.com/catalog?sku=SKU-104' \
-H 'Authorization: Bearer YOUR_UPSTREAM_KEY'Public input: sku
Private value: Authorization header
Output fields: id, title, price
Visibility: private while testing
1. Replace example URL and credential.
2. Run a live route test.
3. Map fields from the returned response.
4. Set limits and pricing before publishing.Map what you actually tested
Click fields in the live response to build the public contract.
Optional AI assistance
Use your own model key for guidance while you stay in control of publishing.
An API builder for data owners and service publishers
Publishing a useful data API involves more than sending a request upstream. You need a clear contract, safe credential handling, limits, trial rules, documentation, and a way to charge for successful usage. Publisher Studio brings those decisions into the same workflow for databases, spreadsheets, HTTP services, and multi-source aggregators.
Start with the source you already operate. Import a working request, choose a starter recipe, connect a supported datasource, or build routes manually. The studio helps construct and test the configuration; you still decide what data may be exposed and whether the final route behaves as your buyers expect.
Import a request without rebuilding it by hand
Paste imports parse cURL, Postman collections, OpenAPI specifications, and HAR captures into editable route configuration.
How it works
Credential-like fields are flagged for private handling. Live URL import is a separate browser-backed path that discovers a page's background requests. Inspect every imported value before exposing a route to buyers.
Map the response you actually tested
Run a live gateway test and use Click-to-Map to choose fields from the returned JSON tree.
How it works
Route and source testing synchronizes the current configuration so you can validate the execution buyers will use. Check required inputs, empty responses, limits, and source failures before expanding access.
Use optional AI help with your own key
The BYOK assistant can help with basic listing details, pricing, and route configuration.
How it works
It uses a pruned live sample for response mapping rather than relying only on a description of the upstream. Review suggested changes and remember that AI-provider usage is associated with the key you supply.
Reuse secrets and continue unfinished work
Encrypted cloud drafts preserve unfinished wizard state, while Vault blocks hold reusable credentials, proxy settings, headers, session profiles, and request policies.
How it works
Guided Interview Mode presents the same configuration as a sequence of questions. Cloning an owned API or aggregator provides a starting point for a related product.
Where this fits into your work.
Data publishers
Package approved SQL tables or spreadsheet data as a documented API with row caps, trials, and recurring or usage-based access.
Agencies and client projects
Configure a private data route, test it with authorized stakeholders, and hand over a clear API contract without rebuilding a billing and documentation portal.
API aggregators
Combine upstream sources through failover or parallel execution, normalize their outputs, and expose the resulting contract through one listing.
Start with a focused test.
Use these steps to set up Publisher Studio and review the result before making it part of a larger workflow.
Open Publisher Studio →- 1
Connect or import a source
Choose a supported database or file source, paste cURL/Postman/OpenAPI/HAR input, import a live URL, or select a starter recipe.
- 2
Test the public contract
Separate public inputs from private values, run a live gateway test, and click response fields to map the desired output. Start with private visibility.
- 3
Package and publish
Set trial allowances, usage caps, plans, and pay-as-you-go pricing. Review the listing and submit it for public marketplace distribution when ready.
Understand each workflow’s cost.
Match the feature’s limits and billing model to the work you want to run.
Explore API listings →Each listing can combine trials, subscription quotas, and pay-as-you-go usage. For web-backed routes, include proxy, browser, and other applicable execution costs when reviewing the economics of a successful request.
Live tests execute through the gateway and can incur applicable charges. Private visibility controls who can access a listing; it does not make execution free. Inspect test charges and vendor analytics before choosing public pricing.
Open an API listing for its Reference, Playground, and Pricing. Check the selected route’s allowances and applicable infrastructure charges before increasing usage.
FAQs
Do I need an OpenAI key to build an API?
No. The BYOK AI assistant is optional. You can configure routes manually, import a request, choose a recipe, or use the guided workflow without enabling it.
Can I test before appearing in the marketplace?
Yes. Private listings provide an instant sandbox for authorized company owners and admins. Public listings follow the marketplace's publication and approval workflow.
Which sources are supported?
The studio supports PostgreSQL, MySQL, MongoDB, Airtable, Excel/CSV/Google Sheets, OpenAPI services, Custom HTTP routes, and HTTP multi-source aggregators. Choose the datasource page for connection-specific details.
Can I reuse one credential across routes?
Yes. Save reusable private configuration in Vault blocks and reference it where supported. This reduces copying, while access and rotation of the underlying credential remain important operational responsibilities.
Your next API starts here.
Open Publisher Studio and turn a source into a product.