Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
Loading...
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
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
Capture the raw DOM of the current page
"actions": [
{
"type": "capture_dom"
}
]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.
size
string
The size of paper the page should be printed to.
Default: view
Accepted: ["view", "fullscreen"]
See universal parameters.
The following captures the current section of the page currently visible in the browser.
An example screenshot in fullscreen mode.
"actions": [
{
"type": "block_dom_removals"
}
]"actions": [
{
"type": "capture_cookies"
}
]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.
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
"actions": [
{
"type": "capture_element",
"selector": ".page_contents",
"timeout": 1000
}
]"actions": [
{
"type": "capture_screenshot",
"size": "view"
}
]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.
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
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 universal parameters.
The following JSON captures the DOM of the page and simplifies it.
"actions": [
{
"type": "capture_snapshot",
}
]"actions": [
{
"type": "generate_simplified_dom"
}
]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
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.
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
{
"type": "", //the type of the action
//other params follow as key value pairs
"key": value //string, number etc.
}{
"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
}"actions": [
{
"type": "click",
"selector": "a.header__logo"
}
]"actions": [
{
"type": "wait",
"selector": "a.header__logo",
"timeout": 5000,
"continueOnFail": true
}
]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
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
See universal parameters.
The following JSON prints the page to a PDF in landscape with margins of 20px.
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": "print",
"page_size": "A4",
"orientation": "landscape",
"margin": 20
}
]"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"
}
]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.
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: 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.
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.
See .
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.
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:
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.
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 You can run this request right now in the .
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 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.
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.
"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
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.
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)
selector
string
The selector 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)
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.
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.
"actions": [
{
"name": "type",
"selector": "#postform-text",
"text": "Hello world!"
}
]"actions": [
{
"name": "type",
"selector": "form input[name="email"]",
"text": "test@test.com"
"timeout": 10000
}
]"actions": [
{
"type": "parse_table",
"selector": ".large_table",
"timeout": 1000
}
]"actions": [
{
"type": "generate_markdown"
}
]{
"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"
}
]
}
}The export full height screenshot of the page showing all items.
Here's a video showing Gaffa filling out the page and waiting for the success modal.
Read more about screen recording here (TODO).
time
integer
The time in milliseconds that the browser should wait.
selector
string
The 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)
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 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.
{
"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/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
}
]
}
}"actions": [
{
"type": "wait",
"time": 1000,
}
]"actions": [
{
"type": "wait",
"selector": "table",
"timeout": 5000,
"continueOnFail": true
}
]{
"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
}
]
}
}
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 demo site. You can run this request right now in the Gaffa API Playground.
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 POST endpoint 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.
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.
{
"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"
}
]
}
}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"
}
]
}
]
}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 demo site. You can run this request right now in the Gaffa API Playground.
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 POST endpoint 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.
Here's an example of the PDF returned by the request after waiting for the article to load.
{
"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"
}
]
}
}