Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
An introduction to the Gaffa Browser API. Learn how you can get started building fast, powerful web automations!
Welcome to the Gaffa documentation site! You'll find everything you need here to get started using API including interactive API definitions, a comprehensive list of actions you can use to interact with our cloud browsers and breakdowns of our example requests you can run right away in our API Playground.
You can sign up to create a Gaffa account . After signing up you'll immediately be able to use the API to start using our which has a number of pre-built automations for simulating a range of scenarios.
When you're ready to use Gaffa on the open web you'll need to choose a plan suitable for your needs and pay at which point the full internet will be available for you to automate.
The easiest way to make your first Gaffa is to start using our where you can see several pre-made and interactive browser request examples of automations we've built against our test site which simulates some common scraping and web automation scenarios. You can run these examples without a paid account and also edit them easily to experiment - once you have a paid account you can also use the playground to build your automations for other sites.
In order to avoid scaling issues for our existing customers we are currently operating a queuing system for new accounts. Simply join the queue when prompted on your account dashboard and we'll let you know when you have access. If you want to jump the queue, you can fill out a short survey to help us better understand our users and we'll approve your account sooner!
Here are all the sample requests we've created for use in the API Playground.
Print to PDF
Export a web page to PDF and wait for elements to load with the Gaffa API.
Convert to Markdown
Export a web page to markdown format - useful feeding into LLM apps.
Infinitely Scroll
Scroll the bottom of a page that infinitely loads items and record the interaction.
Capture Screenshot
Interact with a page and capture the a screenshot of the whole page.
Form Completion
Fill out a form in a human-like way and record the interaction
Type: capture_snapshot
This output type will return a HTML file which captures a static version of the page state. The page will load offline and can be saved to your local machine.
This will:
Load and embed all images on the page.
Embed all css files
Currently, Javascript will be disabled and interactivity might not worked as expected but this feature should be useful for preserving the page state as it was and allowing you to view it offline.
See
The following captures the current section of the page currently visible in the browser.
Here's an example that shows an offline snapshot of a site
"actions": [
{
"type": "capture_snapshot",
}
]Type: block_dom_removals
This action will prevent the page from removing items from the page. This is useful if you are trying to scrape data from a Javascript-based web application that removes items from the page when they are out of view which can make grabbing data difficult.
Using this action will block DOM removals for the rest of the browser request.
See universal parameters.
Capture the cookies of the current page
The following endpoint allows you to list data schemas for your account in a paged list.
Type: capture_cookies
This action will capture the browser cookies currently saved for the web page you are on and return them as a JSON object with key/values.
See universal parameters.
Capture the cookies of the current page
Type: parse_table
Finds a table on the page with a given selector and then converts the table data into a JSON object.
This action first fins the table headers and converts them into property names by converting them to lower case and replacing non-alphanumeric characters with underscores. It then processes each table row and for each cell is extracts the contents and saves a value. At the moment, all values will be string types.
The following endpoint allows you to describe a data schema for parsing an online PDF to JSON.
We use API Keys for authenticating requests to our API. In this document we'll explain how you can manage and use the keys for your account.
Once your account is approved, you will need to create an API key to send your requests to our API. Go to your account Dashboard > API Keys and create a new key with a name. Once the key is created, copy the value and you will immediately be free to start using it to make requests.
If you are worried you have exposed your Gaffa API key or just want to periodically rotate your keys you can create another key and then delete your old keys. Deleted keys will immediately stop working for new requests to the API but past browser requests made using old keys will still be available.
Our API is secured with a customer header X-API-Key whose value should be any current API key in your account. That's all you need to add to your request!
In the following pages you can view all the pre-built requests we've built to show what is possible with the Gaffa web automation API.
You can start using these in the API Playground once you've created an account.
timeout
integer
The maximum amount of time the browser should wait for a file to download. Default: 5,000 (5s)
See universal parameters.
Currently this only works with the following file formats: .pdf, .jpg, .png, .gif, .bmp, .webp, .svg, .tiff, .tif, .img
The following waits 20s for a file to download and then returns it.
And the service responds with the file being in the action output:
"actions": [
{
"type": "download_file",
"timeout": 20000
}
]"actions": [
{
"id": "act_VHhrUbXjZSaYCPTqbBYD4acCzzeFGH",
"type": "download_file",
"query": "download_file?continue_on_fail=false&timeout=20000",
"timestamp": "2025-05-30T15:02:06.6615306Z",
"output": "https://storage.gaffa.dev/brq/downloads/5845df07-3749-424e-9c64-9602be19a857.pdf"
}
]selector
string
The that defines the table whose contents you want to parse.
timeout
integer
The maximum amount of time the browser should wait for the table defined by the selector to appear. Default: 5000 (5s)
See universal parameters.
The following code will wait 1 second for the .large_table element to appear and return a JSON file with the headers and rows converted.
"actions": [
{
"type": "block_dom_removals"
}
]"actions": [
{
"type": "capture_cookies"
}
]Type: generate_simplified_dom
When you're looking at the DOM of a web page, there's a lot of unnecessary data that can be discarded if you are only interested in the page's elements or looking to export the data into a LLM.
The generate_simplified_dom output format processes the HTML in the following way:
Removes all links in the head
Removes all script nodes and links to scripts
Removes all style nodes
Remove style attributes from all elements
Remove all links to stylesheets
Remove all noscript elements outside of the body
Finds all hrefs with query strings and removes the query strings
Important meta tags are kept, all others are removed
Remove all alternate links
Remove all SVG paths
Remove empty text nodes and excessive spacing
See .
The following JSON captures the DOM of the page and simplifies it.
Browser requests are charged in terms of credits based on the following factors:
Request length: Billed at 1 credit per 30 seconds the request takes to run on the browser.
If screen recording is enabled, this is doubled to 2 credits per 30 seconds.
Proxy bandwidth usage: All requests that use a proxy_location parameter use our network of residential proxies and are billed at 1500 credits per 1GB of bandwidth used.
Paid Actions: Some actions will incur additional costs for their usage in a browser request. These are:
Each successful request will deduct the corresponding number of credits from your monthly allowance. Be sure to use as many of your monthly credits as you want as they don't roll over month to month.
Mapping requests are also charged in credits at a rate of 1 credit per mapping request.
Type: capture_dom
This action will capture and return the raw dom of the site which you can then extract data from on your end.
For common AI scenarios you may find this returns too much data so we have provided a generate_simplified_dom action which distills the DOM to only the important elements.
See universal parameters.
Capture the raw DOM of the current page
An example request that uses Gaffa to infinitely scroll down a simulated ecommerce site whilst recording the interaction.
The following example is a request we've pre-built to show you Gaffa's capabilities against our demo site. You can run this request right now in the Gaffa API Playground.
Gaffa automates infinite scrolling on dynamic pages like e-commerce storefronts. Set a duration, and Gaffa will capture all content as it scrolls. Each session can be recorded as a video for playback, letting you debug or review the interaction.
The request below uses the POST endpoint to open the demo site on the ecommerce site simulator with an infinitely scrolling storefront. It will wait for and dismiss a dialog box, wait for a product to load and then scroll down the page for a maximum of 20 seconds - if new items load it will keep scrolling.
Here's a video showing Gaffa scrolling the page for 20 seconds as more items load.
Read more about screen recording here. (TODO)
Type: generate_markdown
The markdown output format can export the data of the page (an article, table etc.) in a human and LLM readable format which removes unnecessary styling data and other "junk" that is only relevant for the site to work properly.
Gaffa exports GitHub flavoured markdown with comments removed and unknown tags ignored.
See universal parameters.
The following converts the current page to markdown:
The following endpoint allows you to query browser request for your account by ID.
This endpoint retrieves information about previous site mapping requests, filterable by id or status
The following endpoint allows you to delete a schema from your account.
An example request that uses Gaffa to dismiss a modal, scroll to the bottom of a page and then capture a full height screenshot.
The following example is a request we've pre-built to show you Gaffa's capabilities against our You can run this request right now in the .
Gaffa can also capture screenshots at any point during your interaction for use in your app or just to work out exactly was being shown at a given point in time. You can capture just what is shown as if you were looking at the screen or the full height of the page.
The request below uses the to open the demo site on the ecommerce page with 20 items, wait for and dismiss the dialog, scroll to the bottom of the page and capture a full height screenshot.
The following endpoint allows you to query for multiple browser requests, either by status or a list of particular ids, submitting a request with neither of these will return all requests for your account.
The following endpoint allows you to update a data schema by ID.
An example request that uses Gaffa to convert a web page page to markdown. This could be used to export web page reports or to print the content of a page in a readable format.
The following example is a request we've pre-built to show you Gaffa's capabilities against our You can run this request right now in the .
Gaffa converts web pages to clean markdown, stripping away styling, scripts, and images. This optimizes content for LLM applications by reducing token usage while preserving essential information.
The request below uses the to open the demo site on the article simulator, wait for the article to load and then generate a markdown from the page's content which you can download for use in your program.
"actions": [
{
"type": "parse_table",
"selector": ".large_table",
"timeout": 1000
}
]size
string
The size of paper the page should be printed to.
Default: A4
Accepted: ["A4"]
margin
integer
The margin of the page in pixels when the page is printed to PDF. Default: 20
orientation
string
Should execution of further actions continue or throw an error if this action fails.
Default: portrait
Accepted: ["portrait", "landscape"]
continue_on_fail
boolean
Should execution of further actions continue or throw an error if this action fails. Default: true
Here's an example of the PDF returned by the request after waiting for the article to load.
"actions": [
{
"type": "print",
"page_size": "A4",
"orientation": "landscape",
"margin": 20
}
]"actions": [
{
"type": "generate_simplified_dom"
}
]"actions": [
{
"type": "capture_dom"
}
]"actions": [
{
"type": "generate_markdown"
}
]{
"url": "https://demo.gaffa.dev/simulate/article?loadTime=3¶graphs=10&images=3",
"proxy_location": null,
"async": false,
"max_cache_age": 0,
"settings": {
"record_request": false,
"actions": [
{
"type": "wait",
"selector": "article"
},
{
"type": "generate_markdown"
}
]
}
}The export full height screenshot of the page showing all items.
Type: wait
Request that the browser waits a given amount of time or for a particular item to appear on the page.
See .
The following code will wait 1 second and then continue with the next action, if provided.
The following code will wait for a table to appear on the page for a maximum of 5 seconds. If the table has not appeared after 5 seconds the next action will be executed, if provided.
An example request that uses Gaffa to automate the completion of a form and waits for a success modal to appear.
The following example is a request we've pre-built to show you Gaffa's capabilities against our demo site. You can run this request right now in the Gaffa API Playground.
Filling forms is tedious, Gaffa can be used to fill out a form in a human-like manner so you can spend time doing much more interesting things.
The request below uses the POST endpoint to open the demo site on the form simulator page with some sections pre-filled (for speed). After typing in the required information and clicking submit, Gaffa waits for the success dialog to show before returning a video of the interaction.
Here's a video showing Gaffa filling out the page and waiting for the success modal.
Read more about screen recording here (TODO).
Type: type
Request that the browser type a particular bit of text into a field.
See .
The following action will type into a particular text field.
The following code will wait a maximum of 10 seconds for the email input to appear in the field and then type in the provided email.
This endpoint creates a new site mapping request and returns the result.
This endpoint retrieves information about a site mapping request.
The following endpoint creates a browser request and either runs it synchronously or returns immediately with an ID so you can check it status later using this endpoint.
{
"url": "https://demo.gaffa.dev/simulate/ecommerce?loadTime=3&showModal=true&modalDelay=0&itemCount=20",
"proxy_location": null,
"async": false,
"max_cache_age": 0,
"settings": {
"record_request": false,
"actions": [
{
"type": "wait",
"selector": "div[role=\"dialog\"]",
"timeout": 10000
},
{
"type": "click",
"selector": "[data-testid=\"accept-all-button\"]"
},
{
"type": "wait",
"selector": "[data-testid^=\"product-1\"]",
"timeout": 5000
},
{
"type": "scroll",
"percentage": 100
},
{
"type": "capture_screenshot",
"size": "fullscreen"
}
]
}
}{
"url": "https://demo.gaffa.dev/simulate/ecommerce?loadTime=3&showModal=true&modalDelay=0&itemCount=infinite",
"proxy_location": null,
"async": false,
"max_cache_age": 0,
"settings": {
"record_request": true,
"actions": [
{
"type": "wait",
"selector": "div[role=\"dialog\"]",
"timeout": 10000
},
{
"type": "click",
"selector": "[data-testid=\"accept-all-button\"]"
},
{
"type": "wait",
"selector": "[data-testid^=\"product-1\"]",
"timeout": 5000
},
{
"type": "scroll",
"percentage": 100,
"max_scroll_time": 20000
}
]
}
}{
"url": "https://demo.gaffa.dev/simulate/form?loadTime=3&showModal=false&modalDelay=0&formType=address&firstName=John&lastName=Doe&address1=123%20Main%20Street&city=London&country=UK",
"proxy_location": null,
"async": false,
"max_cache_age": 0,
"settings": {
"record_request": true,
"actions": [
{
"type": "type",
"selector": "#email",
"text": "johndoe@example.com"
},
{
"type": "type",
"selector": "#state",
"text": "CA"
},
{
"type": "type",
"selector": "#zipCode",
"text": "12345"
},
{
"type": "click",
"selector": "button[type='submit']"
},
{
"type": "wait",
"selector": "[role=\"dialog\"] h2:has-text(\"Success!\")",
"timeout": 10000
}
]
}
}Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
time
integer
The time in milliseconds that the browser should wait.
selector
string
The selector that defines the page element that the browser should wait to appear.
timeout
integer
The maximum amount of time the browser should wait for the provided selector to appear. Default: 5,000 (5s)
selector
string
The selector that defines the page element that the browser should click on.
text
string
The text the browser should enter into the text field.
timeout
integer
The maximum amount of time the browser should wait for the element that needs to be typed in to appear. Default: 5000 (5s)
"actions": [
{
"type": "wait",
"time": 1000,
}
]"actions": [
{
"type": "wait",
"selector": "table",
"timeout": 5000,
"continueOnFail": true
}
]"actions": [
{
"name": "type",
"selector": "#postform-text",
"text": "Hello world!"
}
]"actions": [
{
"name": "type",
"selector": "form input[name="email"]",
"text": "test@test.com"
"timeout": 10000
}
]selector
string
The that defines the element whose contents you want to capture.
timeout
integer
The maximum amount of time the browser should wait for the element defined by the selector to appear. Default: 5000 (5s)
See universal parameters.
The following code will wait 1 second for the .page_contents element to appear and return an html file containg the div's innerHTML.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please and we can enable this feature for your account.
Mapping requests allow you to extract all urls from the sitemap of a website. Gaffa mapping requests have the following useful features:
Sitemap Discovery: No need to find the URL of a site's sitemap, we'll find it automatically.
Caching: If you or another Gaffa user has retrieved a sitemap within a defined timeframe we'll quickly return the cached data instead of having to fetch it all again.
Index Traversal: If the sitemap references other sitemap files we'll automatically process each one of those and add them to the list of urls emsuring the whole hierachy is captured.
Aggregation and Duplicate Prevention: In the rare cases that there are duplicate entries in the sitemap we'll automatically remove them for you and return all URLs sorted alphabetically.
Proxies: Gaffa uses it's residential proxies behind the scenes to ensure your requests to retrieve sitemaps aren't blocked.
The endpoint allows you to create a new request and await the result. It's a request with a simple payload containing the URL of the site you want to extract the sitemap of and a max_cache_age in milliseconds of a response you would accept returned from the cache, the default is 0 and Gaffa will never return a cached response if used.
For the Gaffa site this will return the following response:
As you'll see from the of the site there are also requests to retrieve site mapping requests for your account.
See the for the current cost of mapping requests.
Type: capture_screenshot
Takes a screenshot of the current page. You can choose to take a full screen screenshot showing the whole page or just the current view.
See .
The following captures the current section of the page currently visible in the browser.
An example screenshot in fullscreen mode.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please contact support and we can enable this feature for your account.
"actions": [
{
"type": "capture_element",
"selector": ".page_contents",
"timeout": 1000
}
]size
string
The size of paper the page should be printed to.
Default: view
Accepted: ["view", "fullscreen"]
{
"url": "https://gaffa.dev",
"max_cache_age": 10000
}{
"data": {
"id": "smr_VQW4E66TdcQFZfCs6qavgdowPj3Bzk",
"url": "https://gaffa.dev",
"state": "completed",
"credit_usage": 1,
"from_cache": true,
"started_at": "2025-08-22T11:05:43.328175Z",
"completed_at": "2025-08-22T11:05:47.857941Z",
"running_time": "00:00:04.5297660",
"links": [
"https://gaffa.dev",
"https://gaffa.dev/about",
"https://gaffa.dev/blog",
"https://gaffa.dev/blog/convert-any-web-page-to-llm-ready-markdown-using-gaffa",
"https://gaffa.dev/blog/how-to-extract-and-simplify-a-webpage-dom-with-gaffa",
"https://gaffa.dev/blog/printing-webpages-to-pdf-html-to-pdf-using-gaffa",
"https://gaffa.dev/docs",
"https://gaffa.dev/docs/api-reference/api-authentication",
....and so on
],
"link_count": 52
}
}"actions": [
{
"type": "capture_screenshot",
"size": "view"
}
]percentage
integer
The percentage the page should scroll up or down (+/-) Range: [-100 - 0 - 100] Default: 100 (% - scroll to bottom)
wait_time
integer
After arriving at the desired scroll location this the time Gaffa should monitor for changes to the page height before marking the action as succeeded. Read more . Default: 0
max_scroll_time
integer
The maximum amount of time the page should be scrolled for, in milliseconds. After this time passes, the action will be cancelled. This doesn't cause the action to fail. Default: 20,000 (20s)
scroll_speed
string
The speed which the page should scroll to the desired point. You can read more about this .
Default: medium
Accepted: [slow, medium, instant]
interval
See universal parameters.
Gaffa gives you a flexibility about how fast you scroll down the page which can be really useful to get around restrictions enforced by some sites which detect and limit fast scrolling. By experimenting with scroll_speed and interval you will be able to create the perfect scrolling action for your scenario. The speed settings are as follows:
instant- the page will smoothly scroll to the desired position immediately, useful for sites with no rate limits or loading events caused by scroll actions.
medium - human-like scrolling at a normal speed to the desired position. Gaffa will scroll in much the same way as you would using a mouse.
slow- human-like scrolling at a very slow speed to the desired position. The speed is comparable to scrolling whilst reading a page.
intervalallows you to adjust the scroll speed further by inserting pauses between scroll events.
If wait_time is set to 0 and Gaffa arrives at the desired location then Gaffa will immediately mark the action as succeeded. However, if another value is set then the page will be monitored for the desired amount of time to check for further expansions. If, during this period, the page expands again then Gaffa will continue scrolling to the desired location and the wait will reset.
The following code will scroll half way down the page.
The following code will scroll to the bottom of the page and then keep scrolling when new content loads for a maximum of 25 seconds, waiting 1 second for new content and scrolling at a slow pace with 1 second between scroll actions.
In just a few lines of JSON inlined in a single cURL command, you can automate:
Dismissing Wikipedia’s EU cookie consent banner (if present)
Waiting for the main heading on the Artificial Intelligence article
Scrolling through every section (lazy-loaded images and all)
Capturing a full-page PNG for archiving, visual regression, or documentation
All without installing Playwright or managing headless browsers, Gaffa handles it for you server-side via the.
A valid Gaffa API key
A simple HTTP client (cURL, Postman, axios, etc.).
Familiarity with the for testing browser requests.
Target URL for this tutorial, for this we'll use wikipedia:
If you don't want to use cURL, you can also run this query in the which is an easy way to get started.
Gaffa's screenshot action could be used for a huge number of use cases, but here are a few ideas:
Visual Regression: Integrate into your CI pipeline to compare changes over time.
Archival: Schedule daily captures for audit or compliance purposes.
Monitoring: Automate periodic checks to detect visual bugs or layout shifts.
"actions": [
{
"type": "scroll",
"percentage": 50,
}
]"actions": [
{
"type": "scroll",
"percentage": 100,
"scroll_speed": "slow",
"max_scroll_time": 25000,
"interval": 1000,
"wait_time": 1000
}
]integer
The amount of time, in milliseconds, that scrolling should pause between scroll events. Read more about this below. Default: 0
timeout
integer
The maximum amount of time Gaffa will wait for the page to become scrollable Default: 0
How to Handle Infinite Scrolling and Dynamic Loading with Gaffa’s Scroll Action
Wait: Ensure the main heading (#firstHeading) is loaded.
Scroll: Scroll through the entire page to trigger any lazy-loaded content.
Capture Screenshot: Produce a full-page PNG.
A successful response returns JSON like:
The response contains the following information:
data.id: Unique request identifier.
data.state: "completed" means the workflow finished (even if some steps timed out).
data.credit_usage: Credits consumed for this run.
data.started_at / data.completed_at: Workflow timing.
data.running_time and data.page_load_time: Performance metrics.
data.actions: Each action’s details, including successes, timeouts, and final screenshot URL.
Within the list of actions you'll be able to see the capture_screenshot action which contains an output parameter containing the full size screenshot that was captured.
{
"data": {
"id": "brq_VJX3mbESLiyCFYvZQEUih9RdDYovog",
"url": "https://en.wikipedia.org/wiki/Artificial_intelligence",
"proxy_location": null,
"state": "completed",
"credit_usage": 2,
"http_status_code": 200,
"from_cache": false,
"started_at": "2025-06-09T15:55:46.4235903Z",
"completed_at": "2025-06-09T15:56:27.9381332Z",
"running_time": "00:00:40.7348244",
"page_load_time": "00:00:02.2087117",
"actions": [
{
"id": "act_VJX3memaue6YUgFcn44uNscZbVUpYg",
"type": "wait",
"query": "wait?selector=%23cookie-policy-notice%2C%20.mw-cookie-consent-container&timeout=10000&continue_on_fail=true",
"timestamp": "2025-06-09T15:55:48.6323091Z",
"error": "action_timed_out"
},
{
"id": "act_VJX3mkwfwNPdGiMUpqKr34Tm5xzyUU",
"type": "click",
"query": "click?selector=%23cookie-policy-notice%20button%2C%20.mw-cookie-consent-container%20button&continue_on_fail=true&timeout=5000",
"timestamp": "2025-06-09T15:55:58.7949275Z",
"error": "action_timed_out"
},
{
"id": "act_VJX3mkSJ3sevWRXUCjFy6zwfD172fV",
"type": "wait",
"query": "wait?selector=%23firstHeading&timeout=10000&continue_on_fail=false",
"timestamp": "2025-06-09T15:56:03.9581113Z"
},
{
"id": "act_VJX3mbq9Jgj8EwADszW2AqdeJJXJiY",
"type": "scroll",
"query": "scroll?percentage=100&max_scroll_time=20000&scroll_speed=medium&continue_on_fail=false",
"timestamp": "2025-06-09T15:56:03.9691994Z"
},
{
"id": "act_VJX3mjBQYv8zTsXv1SkgUnBkzNFmJU",
"type": "capture_screenshot",
"query": "capture_screenshot?size=fullscreen&continue_on_fail=false",
"timestamp": "2025-06-09T15:56:20.0727905Z",
"output": "https://storage.gaffa.dev/brq/image/brq_VJX3mbESLiyCFYvZQEUih9RdDYovog/act_VJX3mjBQYv8zTsXv1SkgUnBkzNFmJU_full.png"
}
]
},
"error": null
}curl https://api.gaffa.dev/v1/browser/requests \
--request POST \
--header 'Content-Type: application/json' \
--header 'X-API-Key: YOUR_API_KEY' \
--data '{
"url": "https://en.wikipedia.org/wiki/Artificial_intelligence",
"async": false,
"max_cache_age": 0,
"settings": {
"actions": [
{
"type": "wait",
"selector": "#cookie-policy-notice",
"timeout": 10000,
"continue_on_fail": true
},
{
"type": "click",
"selector": "#cookie-policy-notice",
"continue_on_fail": true
},
{
"type": "wait",
"selector": "#firstHeading",
"timeout": 10000
},
{
"type": "scroll",
"percentage": 100
},
{
"type": "capture_screenshot",
"size": "fullscreen"
}
]
}
}'selector
string
The that defines the page element that the browser should click on.
timeout
integer
The maximum amount of time the browser should wait for the element defined by the selector to appear. Default: 5000 (5s)
See universal parameters.
The following code will wait 1 second and then continue with the next action, if provided.
The following code will wait for the logo to appear for a maximum of 5 seconds and it will continue with the list of actions
When making a Browser Request you can specify a list of actions you wish for us to carry out on the requested web page. These actions conform to the following format:
All actions have the following parameters:
Actions are carried out in the order they are submitted. Every action type has a continue_on_fail parameter which defaults to false, this means that if any action fails the execution of the browser request ends and an error will be returned. Setting continue_on_fail to true ensures that all actions are carried out, regardless of previous action results and an error will not be returned.
As shown above, you can submit a customId with each action you submit to the API. We'll include this Id in the outputs from the browser request so you can find a certain action's output and/or status easily in the response.
When a browser request has completed, information on an action's execution
The Gaffa API supports the following actions detailed below. Click the "read more" buttons to read more information about each type.
The ability to convert websites into LLM-friendly markdown is powerful when building applications for summarization, Q&A, or knowledge extraction. In this guide, you'll learn how to use the Gaffa API to extract the main content of any web page using browser rendering and convert it into structured markdown.
By the end of this guide, you’ll be able to:
Render web pages using Gaffa’s API.
Extract clean page content.
Generate structured markdown suitable for LLM-based Q&A or summarization.
Install Python 3.10 or newer.
Create a virtual environment
Install the required libraries
Get your key and key, and store them as environment variables:
In the code below, we define a function that takes a URL as input, makes a POST request to the Gaffa API, invoking the action, which uses the browser rendering engine to extract the main content of the page and convert it into markdown.
Now that we have the markdown content, we can ask questions about it using the OpenAI API. The function below takes the markdown content and a question as input and uses the OpenAI API to generate a summary based on the provided content. In this case, we are using the model, but you can choose any other model.
The markdown becomes the model’s context, enabling accurate answers about the original web content.
Having defined the functions, we can now create a simple command-line interface that allows users to input a URL and ask questions about the content.
The full script is available to download from the .
To run the script, simply execute it in your terminal:
With your script running, you can enter any URL of any web page, and the script will fetch the markdown content and allow you to ask questions about it.
Making web automation requests has never been so simple.
Browser Requests allow you to send the Gaffa API a URL and a list of actions you want to be carried out, including any outputs you want from the page. We'll carry out the request on our cloud browsers and return you the response with no need to worry about proxies, IP rotation, web automation frameworks and scaling.
There's absolutely zero configuration needed and you can interact with Gaffa from any program that can send web requests. We think it's by far the simplest way to automate simple web tasks and the good news is, we're just getting started and have much more planned.
Running a new browser request is as simple as sending the following . Below, you can see the url () and a list of actions which instruct Gaffa to wait for a table to load and print the page to PDF.
An example request that uses Gaffa to convert an HTML page to a PDF. There are lots of HMTL to PDF API's but Gaffa handles it easily, as well as doing much more.
The following example is a request we've pre-built to show you Gaffa's capabilities against our You can run this request right now in the .
Gaffa's print to PDF feature allows you to export web pages as PDF files easily. Unlike the standard "Print to PDF" in your local browser, Gaffa's feature waits for specific items to load, uses proxies, and scales with your product's growth. Enhance your customer experience and streamline your PDF export process
The request below uses the to open the demo site on the table page, wait for the table to load and then print the webpage to a PDF in size A4 with a margin of 20 and using the portrait orientation.
What is Gaffa?
Gaffa is a powerful API for browser automation which allows you to control real web browsers at scale through a simple interface with no configuration necessary. We'll handle the complexities of managing infrastructure like virtual machines, proxies and caching so you can focus on building powerful and reliable web automation and AI applications!
Gaffa is ready to power your web automations:
"actions": [
{
"type": "click",
"selector": "a.header__logo"
}
]"actions": [
{
"type": "wait",
"selector": "a.header__logo",
"timeout": 5000,
"continueOnFail": true
}
]{
"type": "", //the type of the action
//other params follow as key value pairs
"key": value //string, number etc.
}Real browsers - headless browsers are popular but we make it simple to control real cloud-hosted browsers at scale which render JavaScript sites exactly as they would on a local machine, are harder to detect when doing scraping and allow full observability. We're also planning to allow you to go beyond just being able to control web browsers!
Proxies - you can easily choose to route your traffic through a network of residential proxy IP addresses to help avoid bot-detection on sites you are trying to automate.
Scalable - whether you want to control a single cloud browser or 100s in parallel with Gaffa you can do that easily without one thought about infrastructure management.
Powerful data processing - once you've accessed your desired site you can export your data in a constantly growing number of formats. If you want the page content in markdown to feed into a large language model or an image to feed into a vision modal we can help.
We'll be sporadically announcing updates and new features in our newsletter - sign up here.
Gaffa makes proxying your traffic through a global network of residential proxies super simple. Setting proxy_location in your request will allow you to utilize one of our partner third party proxy services to gain local access to a site.
Not setting a proxy_location will mean the request does not use a proxy server and will use a generic datacenter IP.
United States
us
Ireland
ie
Singapore
sg
France
fr
Currently all our IP addresses are residential IP addresses which are procured through reputable third parties.
IP rotation is an essential part of any web data, scraping or automation task. In Gaffa, each browser request is treated as unique. We regularly rotate the IP addresses used so you should assume that each request will be carried out from a different IP address from the last.
Whilst we'll do our best to provide access to as wide a range of sites as possible we may have to restrict access to certain sites to prevent abuse of our service or of other services. Our proxy partners may also enforce restrictions on certain sites and categories of sites which we don't have any control over.
max_cache_age: integer
When we were building Gaffa we noticed that a lot of pre-existing scraping tools don't allow users to easily share their scraped web data with each other, despite many users requesting the same web pages on the same sites. Not only is this a waste of a user's allowance, it also puts a burden on the site owners who are serving the same data to different users for the same purpose. Because of this in Gaffa we have created a service-wide cache.
When making a browser request you can provide a max_cache_ageparameter which is a number in seconds equal or greater than 0. This values denotes the maximum age of data you would accept from the API.
If another user of our service has requested the same URL with exactly the same parameters and actions as you in this chosen timeframe then the response will be returned to you immediately and the response will not be carried out on one of our browsers. If there are multiple identical requests in the given timeframe then the most recent will be returned.
This will save you time waiting for the response, as well as credits, because requests returned from the cache don't use any bandwidth.
record_request: boolean
By specifying record_request you can ask Gaffa to screen record your automation and return a video in the response allowing you to view the magic happening or to debug your automation.
Recording requests comes at an additional cost.
max_media_bandwidth: integer
If you are using Gaffa on a site with lots of images and videos and more interested in the text data on the page, you can cap how much data a page loads in MB using the max_media_bandwidth setting. This makes your automation faster and prevents spending credits on data you aren't interested in.
With the max_media_bandwidth value set, Gaffa monitors data being downloaded by the page and when downloaded data exceeds the given number of MB, all further downloads of images or video will be cancelled.
max_media_bandwidth defaults to null meaning downloads are not capped. Setting a value of 0 will cause no images to load which can work on some sites but on others this could lead to the site thinking you are using an ad blocker.
time_limit: integer
Using the setting time_limit caps the maximum running time of the request in milliseconds. If this time expires all incomplete actions will be cancelled and the request will return an error. This cap has to be less than the maximum request running time dictated by your plan and if not set, will default to this value.
We currently support ten different types of actions which you can read more about here.
We believe your AI Agents should be able to use the internet exactly how humans would. Gaffa can help you get access to sites with some of the most challenging anti-bot restrictions using a combination of proxies, human-like behavior, captcha solving and a custom browser implementation. We handle and maintain all of that so you can focus on building your solution!
We've created a number of sample browser requests you can read about here or you can jump straight into the API Playground to start running them right now.
Check out our API reference for more details about the endpoints available, particularly those you can use to query for past requests by id or status.
Read the full documentation for these actions here.
Here's an example of the PDF returned by the request after waiting for the table to load.
python -m venv venv && source venv/bin/activatepip install requests openaiGAFFA_API_KEY=your_gaffa_api_key
OPENAI_API_KEY=your_openai_api_keyimport requests
import openai
GAFFA_API_KEY = os.getenv("GAFFA_API_KEY")
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
# Fetch the markdown content from Gaffa
def fetch_markdown_with_gaffa(url):
payload = {
"url": url,
"proxy_location": None,
"async": False,
"max_cache_age": 0,
"settings": {
"record_request": False,
"actions": [
{
"type": "wait",
"selector": "article"
},
{
"type": "generate_markdown"
}
]
}
}
# Set the headers for the request
headers = {
"x-api-key": GAFFA_API_KEY,
"Content-Type": "application/json"
}
# Make the POST request to the Gaffa API
print("Calling Gaffa API to generate markdown...")
response = requests.post("https://api.gaffa.dev/v1/browser/requests", json=payload, headers=headers)
response.raise_for_status()
# Extract the markdown URL from the response
markdown_url = response.json()["data"]["actions"][1]["output"]
# Fetch the markdown content from the generated URL
print(f"📥 Fetching markdown from: {markdown_url}")
markdown_response = requests.get(markdown_url)
markdown_response.raise_for_status()
return markdown_response.textdef ask_question(markdown, question):
openai.api_key = OPENAI_API_KEY
prompt = (
f"You are an assistant helping analyze different webpages.\n\n"
f"Markdown content:\n{markdown[:3000]}\n\n"
f"Question: {question}\nAnswer as clearly as possible."
)
response = openai.ChatCompletion.create(
model="gpt-3.5-turbo",
messages=[
{"role": "user", "content": prompt}
]
)
return response.choices[0].message["content"]def main():
url = input("Enter the URL of the article: ")
try:
markdown = fetch_markdown_with_gaffa(url)
print("\n✅ Markdown successfully retrieved from Gaffa.\n")
while True:
question = input("Ask a question about the content (or type 'exit'): ")
if question.lower() == "exit":
break
answer = ask_question(markdown, question)
print(f"\n💬 Answer: {answer}\n")
except Exception as e:
print(f"⚠️ Error: {e}")
if __name__ == "__main__":
main()python your_script_name.py{
"url": "https://demo.gaffa.dev/simulate/table?loadTime=3&rowCount=20",
"proxy_location": null,
"async": false,
"max_cache_age": 0,
"max_media_bandwidth": null,
"settings": {
"record_request": false,
"actions": [
{
"type": "wait",
"selector": "table"
},
{
"type": "print",
"size": "A4",
"margin": 20,
"orientation": "portrait"
}
]
}
}{
"url": "https://demo.gaffa.dev/simulate/table?loadTime=3&rowCount=20",
"proxy_location": null,
"async": false,
"max_cache_age": 0,
"settings": {
"record_request": false,
"actions": [
{
"type": "wait",
"selector": "table"
},
{
"type": "print",
"size": "A4",
"margin": 20,
"orientation": "portrait"
}
]
}
}type
string
The type name of the action.
continue_on_fail
boolean
Should execution of further actions continue or throw an error if this action fails.
Default: false
customId
string
A customId to help you find the action in the response.
Default: null
click
Click on a given element
scroll
Scroll to a particular point on the page or, in the case of pages with infinite scrolling, scroll until a given time has elapsed.
type
Type the provided text into a given element
wait
Wait for a given time to elapse or an element to appear on page before proceeding to the next action.
capture_cookies
Save a JSON object of cookies for the current page
capture_dom
Export the raw DOM page data
capture_screenshot
Capture a screenshot of the web page
capture_snapshot
Create a completely static version of the web page which can be accessed offline
download_file
Download an online file using Gaffa
generate_markdown
Convert the page into markdown
generate_simplified_dom
Generate a simplified version of the DOM
parse_json
Parse online data to a defined JSON schema
print
Print the web page to a PDF
{
"id": "", //a unique id given to the action by Gaffa
"type": "capture_screenshot", //the type of the action
"query": "", //a representation of the action in querystring format
"timestamp": "", //the UTC timestamp the action was executed
"output": "" //if the action has an output you will find a url for this here,
"error": "" //if the requesst fails the error message will be returned here
}Beta Feature: This feature is currently in beta and restricted to approved users. If you're are interested in trying it, please and we can enable this feature for your account.
Type: parse_json
The parse_json action extracts data from web pages and online PDFs. It uses AI to parse web content from text into a pre-defined data schema and return it as a JSON object.
The action allows you to convert unstructured content such as academic papers, forms, and webpages into JSON objects, which you can use in automations, analysis, or further processing.
This feature currently works for online PDFs and web page text.
See .
A data schema tells the model exactly what JSON structure to produce.
You can define schemas in two ways:
Inline schemas (defined directly inside the action)
Reusable schemas (created via the Schema API and referenced by ID in your requests)
A schema has:
Each field in the fields array has:
This example shows:
Simple fields (string, datetime) for basic data
Object fields for grouped related data with nested fields
Array fields for lists of items with nested fields defining each item's structure
Instead of defining schemas inline every time, they can be saved to your Gaffa account and be reused across multiple requests. This makes your actions more readable, easier to maintain, and ensures consistency when parsing similar content.
Use the endpoint to create a reusable schema:
Response:
Save the id returned in the response, you'll use this to reference the schema in your requests
Allows you to view all schemas saved to your account:
Endpoint:
Allows you to modify an existing schema by its ID:
Endpoint:
Removes a schema from your account:
Endpoint:
Simple List Extraction
Nested Objects
The credits this action uses depends on the model used. Here are the current supported models and their pricing:
model
string`
The AI model you wish to use to parse the content into JSON.
Default: gpt-4o-mini
Accepted: ["gpt-4o-mini"]
input_token_cap
int
The max number of source input tokens that will be passed to the AI model to parse. This can be used to prevent unnecessary credit usage. If your source input is longer than the token cap, it will be abbreviated. Default: 1,000,000
selector
string
The that defines an element you want to parse the content of - this is useful if you are only interested in the contents of a certain element.
output_type
string
Should the action output be saved to a file where a URL will be returned or should the parsed JSON object be included directly in the request.
Default: file
Accepted: ["file", "inline"]
max_pages
int
If you are parsing a PDF you can specify this parameter to limit the number of pages that are passed to the LLM. Default: no limit
object
Nested structured object
string
Text value
data_schema_id
string
The id of the data schema you have defined that you want to transform the content into.
You must provide a data_schema or data_schema_id with your request.
data_schema
json
A JSON object describing the data_schema you want to transform the content into.
You must provide a data_schema or data_schema_id with your request.
instruction
string
description
string
Explains what data the schema extracts and provides context to help the AI model understand the extraction goal.
Example: "Extract product details from this e-commerce product page"
fields
array
Each field defines a piece of data to extract from the content. See field properties below.
name
string
This identifies the schema and should clearly indicate what data it extracts.
Example: "ProductInfo", "ArticleMetadata", "ContactForm"
descripton
string
Include details about format, handling of missing values, or special cases.
Example: "Maximum salary in GBP. If only one value is provided, use the same value for both min and max. Return null if not provided."
fields
array
Required only for object and array types.
name
string
Use clear, descriptive names that follow your preferred naming convention (e.g., snake_case or camelCase). Example: "product_name", "published_date", "author_email"
type
string
Determines how the AI interprets and structures the extracted data. Must be one of the supported types below.
array
List of items
boolean
True/False
datetime
timestamp
decimal
Precise decimal
double
Floating-point number
integer
Whole number
gpt-4o-mini
1 credit per 10,000 input tokens
4 credits per 10,000 output tokens
A custom instruction, in addition to any detail you have added to the data schema, that you want to include with this particular parse.
{
"type": "parse_json",
"data_schema": {
"name": "ArticleMetadata",
"description": "Extract metadata from an article",
"fields": [
{
"type": "string",
"name": "title",
"description": "Article title"
},
{
"type": "string",
"name": "author",
"description": "Author name"
},
{
"type": "datetime",
"name": "published",
"description": "Publication date"
}
]
},
"model": "gpt-4o-mini",
"output_type": "inline"
}curl -L \
--request POST \
--url 'https://api.gaffa.dev/v1/schemas' \
--header 'X-API-Key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"name": "ProductInfo",
"description": "Extract product details from e-commerce pages",
"fields": [
{
"type": "string",
"name": "product_name",
"description": "The product title"
},
{
"type": "decimal",
"name": "price",
"description": "Current price"
},
{
"type": "boolean",
"name": "in_stock",
"description": "Product availability"
},
{
"type": "object",
"name": "ratings",
"description": "Product rating information",
"fields": [
{
"type": "double",
"name": "average",
"description": "Average rating score"
},
{
"type": "integer",
"name": "total_reviews",
"description": "Number of reviews"
}
]
},
{
"type": "array",
"name": "tags",
"description": "Product tags",
"fields": [
{
"type": "string",
"name": "tag",
"description": "Individual tag name"
}
]
}
]
}'{
"id": "schema_abc123xyz",
"name": "ProductInfo",
"description": "Extract product details from e-commerce pages",
"fields": [...]
}curl -L \
--url 'https://api.gaffa.dev/v1/schemas' \
--header 'X-API-Key: YOUR_API_KEY' \
--header 'Accept: */*'curl -L \
--request PUT \
--url 'https://api.gaffa.dev/v1/schemas/{id}' \
--header 'X-API-Key: YOUR_API_KEY' \
--header 'Content-Type: application/json' \
--data '{
"id": "schema_abc123xyz",
"name": "ProductInfo",
"description": "Extract detailed product information from e-commerce pages",
"fields": [
{
"type": "string",
"name": "product_name",
"description": "The product title"
},
{
"type": "decimal",
"name": "price",
"description": "Current price"
},
{
"type": "string",
"name": "brand",
"description": "Product brand name"
}
]
}'curl -L \
--request DELETE \
--url 'https://api.gaffa.dev/v1/schemas/{id}' \
--header 'X-API-Key: YOUR_API_KEY' \
--header 'Accept: */*'{
"name": "TagList",
"description": "Extract article tags",
"fields": [
{
"type": "array",
"name": "tags",
"description": "List of article tags",
"fields": [
{
"type": "string",
"name": "tag",
"description": "Individual tag name"
}
]
}
]
}{
"name": "ProductWithReviews",
"description": "Product details with nested review data",
"fields": [
{
"type": "string",
"name": "product_name",
"description": "Product name"
},
{
"type": "object",
"name": "pricing",
"description": "Pricing information",
"fields": [
{
"type": "decimal",
"name": "current_price",
"description": "Current price"
},
{
"type": "decimal",
"name": "original_price",
"description": "Original price before discount"
},
{
"type": "integer",
"name": "discount_percentage",
"description": "Discount percentage"
}
]
}
]
}Retrieves a paginated list of data schemas.
Payload of PagedResult containing DataSchema
Payload of PagedResult containing DataSchema
Creates a new data schema definition and returns the created schema.
The unique identifier for the data schema.
The name of the schema or field.
A description of the schema or field.
Payload of DataSchema
This endpoint retrieves a browser request by its ID.
The unique identifier of the browser request to retrieve.
The unique identifiers of the browser request to retrieve.
The browser request
Browser request not found
This endpoint retrieves sitemap requests in bulk by id or status.
The unique identifiers of the sitemap requests to retrieve.
{"value":"smr_1234567890abcdef,smr_0987654321fedcba"}The statuses of the sitemap requests to filter by. Valid values: pending, completed, failed
{"value":"completed,pending"}Items to return per page (default: 30).
{"value":30}Page number of the pagination (default: 1).
{"value":1}A collection of sitemap requests that match the criteria
Invalid query parameters
This endpoint retrieves browser requests in bulk by id or status.
The unique identifiers of the browser requests to retrieve.
{"value":"brq_V2P6PqrZpycFtbc7mtXE4tsNbeg2N6,brq_V2P6X38RDRMRyYcNJ82qPSH5eFfQRD"}The statuses of the browser requests to filter by. Valid values: pending, running, completed, failed
{"value":"completed,running"}Items to return per page (default: 30).
{"value":20}Page number of the pagination (default: 1).
{"value":1}A collection of browser requests that match the criteria
Invalid query parameters
Updates an existing data schema by its ID and returns the updated schema.
The unique identifier for the data schema.
The name of the schema or field.
A description of the schema or field.
Payload of DataSchema
This endpoint processes a website's sitemap and returns all URLs found within it.
The url you want our sitemap reader to process on your behalf
Maximum cache age in seconds for this request. If a cached result exists within this timeframe, it will be returned. Default is 0 (no cache).
The sitemap request response detailing the URLs found
The sitemap request timed out after 60 seconds
The requested site is unavailable
This endpoint retrieves a sitemap request by its ID.
The unique identifier of the sitemap request to retrieve.
The sitemap request
Sitemap request not found
This endpoint loads the required URL in our browser and then performs the selected actions.
The location of the proxy server that your request will be routed through, null means no proxy is used
nullThe url you want our browsers to visit on your behalf
Whether the request should be processed asynchronously, synchronous requests can be maximum 60 seconds long.
trueThe maximum age of a cached result in seconds. 0 means the cache will never be used
0The browser request response detailing the state and output of the request
The browser request timed out - an example error
Payload of DataSchema
A collection of sitemap requests that match the criteria
Payload of DataSchema
GET /v1/schemas HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Accept: */*
{"data":{"total_pages":1,"total_records":3,"results":[{"id":"schema_abc123def456","name":"Customer Schema","description":"Data schema for customer information","fields":[{"type":"string","name":"firstName","description":"Customer's first name","fields":[]},{"type":"string","name":"lastName","description":"Customer's last name","fields":[]},{"type":"integer","name":"age","description":"Customer's age in years","fields":[]},{"type":"boolean","name":"isActive","description":"Whether the customer account is active","fields":[]}]},{"id":"schema_xyz789uvw123","name":"Product Schema","description":"Data schema for product information","fields":[{"type":"string","name":"productName","description":"Name of the product","fields":[]},{"type":"decimal","name":"price","description":"Product price","fields":[]},{"type":"boolean","name":"inStock","description":"Whether the product is in stock","fields":[]},{"type":"array","name":"tags","description":"Product tags","fields":[{"type":"string","name":"tagItem","description":null,"fields":[]}]}]},{"id":"schema_hij456klm789","name":"Order Schema","description":"Data schema for order processing","fields":[{"type":"string","name":"orderId","description":"Unique order identifier","fields":[]},{"type":"datetime","name":"orderDate","description":"Date when order was placed","fields":[]},{"type":"object","name":"customer","description":"Customer information","fields":[{"type":"string","name":"customerId","description":"Customer identifier","fields":[]},{"type":"string","name":"email","description":"Customer email address","fields":[]}]},{"type":"decimal","name":"totalAmount","description":"Total order amount","fields":[]}]}],"page":1,"page_size":30},"error":null}{"id":"schema_abc123def456","name":"Customer Schema","description":"Data schema for customer information","fields":[{"type":"string","name":"firstName","description":"Customer's first name","fields":[]},{"type":"string","name":"lastName","description":"Customer's last name","fields":[]},{"type":"integer","name":"age","description":"Customer's age in years","fields":[]},{"type":"boolean","name":"isActive","description":"Whether the customer account is active","fields":[]}]}POST /v1/schemas HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Content-Type: application/json
Accept: */*
Content-Length: 518
"{\"name\":\"Customer Schema\",\"description\":\"Data schema for customer information\",\"fields\":[{\"type\":\"string\",\"name\":\"firstName\",\"description\":\"Customer's first name\",\"fields\":[]},{\"type\":\"string\",\"name\":\"lastName\",\"description\":\"Customer's last name\",\"fields\":[]},{\"type\":\"integer\",\"name\":\"age\",\"description\":\"Customer's age in years\",\"fields\":[]},{\"type\":\"boolean\",\"name\":\"isActive\",\"description\":\"Whether the customer account is active\",\"fields\":[]}]}"GET /v1/browser/requests/{id}?id=text HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Accept: */*
{
"id": "text",
"url": "text",
"proxy_location": "text",
"state": "text",
"credit_usage": 1,
"error": "text",
"error_reason": "text",
"actual_url": "text",
"http_status_code": 1,
"from_cache": true,
"started_at": "2025-12-09T20:18:54.873Z",
"completed_at": "2025-12-09T20:18:54.873Z",
"running_time": "text",
"page_load_time": "text",
"actions": [
{
"id": "text",
"type": "text",
"custom_id": "text",
"timestamp": "2025-12-09T20:18:54.873Z",
"output": {},
"reference": "text",
"iterations": 1,
"actions": [
{
"id": "text",
"type": "text",
"custom_id": "text",
"timestamp": "2025-12-09T20:18:54.873Z",
"output": {},
"reference": "text",
"iterations": 1,
"actions": [
"[Circular Reference]"
],
"error": "text"
}
],
"error": "text"
}
],
"video": "text"
}{"total_pages":0,"total_records":1,"results":[{"id":"smr_1234567890abcdef","url":"https://example.com","state":"completed","credit_usage":1,"error":null,"error_reason":null,"from_cache":false,"started_at":"2024-01-01T12:00:00+00:00","completed_at":"2024-01-01T12:01:00+00:00","running_time":"00:01:00","links":["https://example.com/","https://example.com/about","https://example.com/products"],"link_count":3}],"page":1,"page_size":30}GET /v1/site/map HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Accept: */*
DELETE /v1/schemas/{id} HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Accept: */*
{"data":{"total_pages":1,"total_records":2,"results":[{"id":"brq_V2PUfFA8AQPAQ5VEsewpxdGUSZkgKP","url":"https://demo.gaffa.dev/simulate/table?loadTime=3&rowCount=20","proxy_location":null,"state":"completed","credit_usage":4,"error":null,"error_reason":null,"actual_url":null,"http_status_code":200,"from_cache":false,"started_at":"2024-11-22T16:31:13.128103+00:00","completed_at":"2024-11-22T16:31:47.020851+00:00","running_time":null,"page_load_time":"00:00:03.4705813","actions":[{"id":"act_V2PUfETiTdXwzEgAW2NPURnATW7we9","type":"wait","custom_id":null,"timestamp":"2024-11-22T16:31:16.6080484+00:00","output":null,"reference":null,"iterations":null,"actions":null,"error":null},{"id":"act_V2PUfBreQxHR2SNqGXuPzzWoiyRsrm","type":"print","custom_id":null,"timestamp":"2024-11-22T16:31:40.5760333+00:00","output":"https://storage.gaffa.dev/brq/pdf/brq_V2PUfFA8AQPAQ5VEsewpxdGUSZkgKP/act_V2PUfBreQxHR2SNqGXuPzzWoiyRsrm.pdf","reference":null,"iterations":null,"actions":null,"error":null}],"video":"https://storage.gaffa.dev/brq/video/brq_V2PUfFA8AQPAQ5VEsewpxdGUSZkgKP.mp4"},{"id":"brq_V2NmHY9FsvPQEGbfVBSeV6UCp2SXjC","url":"https://demo.gaffa.dev/simulate/article?loadTime=3¶graphs=10&images=3","proxy_location":null,"state":"completed","credit_usage":1,"error":null,"error_reason":null,"actual_url":null,"http_status_code":200,"from_cache":false,"started_at":"2024-11-22T12:52:48.708264+00:00","completed_at":"2024-11-22T12:52:54.25994+00:00","running_time":null,"page_load_time":"00:00:00.8094888","actions":[{"id":"act_V2NmHijnQa9iPDNcvhjS2GGFt5se8j","type":"wait","custom_id":null,"timestamp":"2024-11-22T12:52:49.5690537+00:00","output":null,"reference":null,"iterations":null,"actions":null,"error":null},{"id":"act_V2NmHgs27VJKB49YavtK4CcyErdfvD","type":"generate_markdown","custom_id":null,"timestamp":"2024-11-22T12:52:52.8353136+00:00","output":"https://storage.gaffa.dev/brq/md/brq_V2NmHY9FsvPQEGbfVBSeV6UCp2SXjC/act_V2NmHgs27VJKB49YavtK4CcyErdfvD.md","reference":null,"iterations":null,"actions":null,"error":null}],"video":null},{"id":"brq_V2HvS2cw4Z2wonqEAwbxoxjrkmRdEM","url":"https://demo.gaffa.dev/simulate/article","proxy_location":null,"state":"failed","credit_usage":0,"error":null,"error_reason":null,"actual_url":null,"http_status_code":null,"from_cache":false,"started_at":null,"completed_at":null,"running_time":null,"page_load_time":null,"actions":null,"video":null}],"page":1,"page_size":30},"error":null}GET /v1/browser/requests HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Accept: */*
{
"id": "text",
"name": "text",
"description": "text",
"fields": [
{
"type": 0,
"name": "text",
"description": "text",
"fields": [
{
"type": 0,
"name": "text",
"description": "text",
"fields": [
"[Circular Reference]"
]
}
]
}
]
}PUT /v1/schemas/{id} HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Content-Type: application/json
Accept: */*
Content-Length: 1082
"{\"name\":\"Updated Product Schema\",\"description\":\"Enhanced schema for product information with additional fields\",\"fields\":[{\"type\":\"string\",\"name\":\"productName\",\"description\":\"Name of the product\",\"fields\":[]},{\"type\":\"decimal\",\"name\":\"price\",\"description\":\"Product price\",\"fields\":[]},{\"type\":\"boolean\",\"name\":\"inStock\",\"description\":\"Whether the product is in stock\",\"fields\":[]},{\"type\":\"array\",\"name\":\"tags\",\"description\":\"Product tags\",\"fields\":[{\"type\":\"string\",\"name\":\"tagItem\",\"description\":null,\"fields\":[]}]},{\"type\":\"array\",\"name\":\"categories\",\"description\":\"Product categories\",\"fields\":[{\"type\":\"string\",\"name\":\"category\",\"description\":null,\"fields\":[]}]},{\"type\":\"object\",\"name\":\"specifications\",\"description\":\"Technical specifications\",\"fields\":[{\"type\":\"string\",\"name\":\"dimensions\",\"description\":\"Product dimensions\",\"fields\":[]},{\"type\":\"double\",\"name\":\"weight\",\"description\":\"Product weight in grams\",\"fields\":[]}]}]}"{"id":"smr_1234567890abcdef","url":"https://example.com","state":"completed","credit_usage":1,"error":null,"error_reason":null,"from_cache":false,"started_at":"2024-01-01T12:00:00+00:00","completed_at":"2024-01-01T12:00:30+00:00","running_time":"00:00:30","links":["https://example.com/","https://example.com/about","https://example.com/products","https://example.com/contact"],"link_count":4}POST /v1/site/map HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Content-Type: application/json
Accept: */*
Content-Length: 55
"{\"url\":\"https://example.com\",\"max_cache_age\":0}"GET /v1/site/map/{id} HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Accept: */*
{
"id": "text",
"url": "text",
"state": "text",
"credit_usage": 1,
"error": "text",
"error_reason": "text",
"from_cache": true,
"started_at": "2025-12-09T20:18:54.873Z",
"completed_at": "2025-12-09T20:18:54.873Z",
"running_time": "text",
"links": [
"text"
],
"link_count": 1
}{"data":{"id":"brq_V2P6PqrZpycFtbc7mtXE4tsNbeg2N6","url":"https://demo.gaffa.dev/simulate/table?loadTime=3&rowCount=20","proxy_location":null,"state":"completed","credit_usage":1,"error":null,"error_reason":null,"actual_url":null,"http_status_code":200,"from_cache":false,"started_at":"2024-11-22T14:33:38.7762685+00:00","completed_at":"2024-11-22T14:33:42.7135779+00:00","running_time":null,"page_load_time":"00:00:00.1902889","actions":[{"id":"act_V2P6Q3fSHhBWAhf4BQJxj9oYbQF1V9","type":"wait","custom_id":null,"timestamp":"2024-11-22T14:33:38.9665719+00:00","output":null,"reference":null,"iterations":null,"actions":null,"error":null},{"id":"act_V2P6Q6BuQhoYDAVkQMVSKkkwmUrArb","type":"print","custom_id":null,"timestamp":"2024-11-22T14:33:42.3025888+00:00","output":"https://storage.gaffa.dev/brq/pdf/brq_V2P6PqrZpycFtbc7mtXE4tsNbeg2N6/....","reference":null,"iterations":null,"actions":null,"error":null}],"video":null},"error":null}POST /v1/browser/requests HTTP/1.1
Host: api.gaffa.dev
X-API-Key: YOUR_API_KEY
Content-Type: application/json
Accept: */*
Content-Length: 370
"{\"proxy_location\":null,\"url\":\"https://demo.gaffa.dev/simulate/table?loadTime=3&rowCount=20\",\"async\":false,\"max_cache_age\":0,\"settings\":{\"record_request\":false,\"actions\":[{\"type\":\"wait\",\"selector\":\"table\"},{\"type\":\"print\",\"size\":\"A4\",\"margin\":20}],\"time_limit\":60000,\"max_media_bandwidth\":null,\"output\":null,\"block_ads\":false}}"