Gaffa is a powerful API for browser automation that lets you control real web browsers at scale through a simple interface with no configuration required. We'll handle the complexities of managing infrastructure, such as virtual machines, proxies, and caching, so you can focus on building powerful, reliable web automation and AI applications!

Key features

Gaffa is ready to power your web automations:

• Simplicity - there's no need to learn another new framework; Gaffa is accessible through a simple REST API - just tell it what site you want to visit and what actions you want to perform, and it will be carried out as soon as you send the request.

• 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 let you go beyond just controlling 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.

Ready to work with Gaffa?

Stay up to date

We'll be announcing updates and new features in our newsletter - sign up here.

Welcome to the Gaffa documentation site! You'll find everything you need here to get started using the 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.

^{Want to build faster with AI assistance?}

You can use Gaffa's llms.txt file to give AI assistants like ChatGPT or Claude instant, accurate context about the Gaffa API, so they can generate working code for you straight away, without you having to explain the API yourself. Learn how to use the Gaffa LLMs.txt file →

Browser Requests

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:

  • JSON Parsing

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

Mapping requests are also charged in credits at a rate of 1 credit per mapping request.

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.

Parameters

See universal parameters.

Usage

Capture the cookies of the current page

"actions": [
    {
      "type": "block_dom_removals"
    }
]

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.

Parameters

See universal parameters.

Usage

Capture the cookies of the current page

"actions": [
    {
      "type": "capture_cookies"
    }
]

Type: capture_dom

This action will capture and return the site's raw DOM, which you can then extract data from on your end.

For common AI scenarios, you may find that this returns too much data, so we have provided a generate_simplified_dom , an action that distills the DOM to only the important elements.

Parameters

See universal parameters.

Usage

Capture the raw DOM of the current page

Example Output

On the following pages, you can view all prebuilt requests we've created 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 example is a request we've prebuilt to show you Gaffa's capabilities on our demo site. You can run this request right now in the Gaffa API Playground.

Gaffa's print-to-PDF feature allows you to easily export web pages as PDF files. 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

API Request

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 A4 size with a 20-point margin and in portrait orientation.

Actions

Read the full documentation for these actions here.

Response

Here's an example of the PDF returned by the request after the table has loaded.

Creating Keys

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 can immediately start using it to make requests.

Deleting Keys

If you are worried you have exposed your Gaffa API key, or just want to periodically rotate your keys, you can create a new key and then delete your old keys. Deleted keys will immediately stop working for new API requests, but past browser requests made using old keys will still be available.

Authenticating Requests

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!

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 in our cloud browsers and return the response, so you don't have to worry about proxies, IP rotation, web automation frameworks, or 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 basic web tasks, and the good news is that we're just getting started and have much more planned.

How It Works

A browser request consists of three main components:

1. Parameters — Control the basics like URL, proxy location, and caching

2. Settings — Configure recording, media limits, and timing

3. Actions — Define the tasks you want performed on the page

Running a new browser request is as simple as sending the following . Below, you can see the URL () and a list of actions that instruct Gaffa to wait for the table to load, then print the page to PDF.

You can read more about this particular example and how you can run it right now in our API Playground .

We believe your AI Agents should be able to use the internet exactly how humans would. Gaffa can help you access sites with some of the most challenging anti-bot restrictions by combining proxies, human-like behaviour, captcha solving, and a custom browser implementation. We handle and maintain all of that so you can focus on building your solution!

— Learn about URL, proxy settings, async mode, and caching

— Explore recording, media bandwidth controls, and time limits

— Discover all available actions like screenshots, markdown generation, and more

— View pre-built requests and start using them in the API Playground

— Complete endpoint documentation and technical details

We've created a number of sample browser requests you can read about , or you can jump straight into the to run them right now.

Check out our API reference for more details on the available endpoints, particularly .

Parameters are the top-level settings that control the fundamental behaviour of your automation. These parameters define where your request goes, how it's routed, whether it runs synchronously or asynchronously, and how caching is handled.

Below you'll find detailed documentation for each available parameter.

Proxy servers

Gaffa makes it super simple to proxy your traffic through a global network of residential proxies. 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.

Available Locations

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 each request is made from a different IP address than 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 that we don't have any control over.

max_cache_age: integer

When we were building Gaffa, we noticed that many existing scraping tools don't let users easily share their scraped web data, even though many users request the same pages on the same sites. Not only is this a waste of a user's allowance, but 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, we have created a service-wide cache in Gaffa.

When making a browser request, you can provide a max_cache_age parameter that is a number in milliseconds equal to or greater than 0. This value 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 timeframe, the response will be returned to you immediately and will not be processed by 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 a response and credits, because requests returned from the cache don't use any bandwidth.

The settings object allows you to configure how your browser requests behave. It currently supports three parameters that control recording, media downloads, and execution time limits.

You can read more about all available settings parameters .

Type: capture_screenshot

Takes a screenshot of the current page. You can take a full-screen screenshot of the entire page or just the current view.

Type: capture_element

Returns the , essentially the contents, of a particular element on the page. This can be used when you are only interested in the contents of a particular element.

Type: capture_snapshot

This output type will return an HTML file that 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.

Type: click

Request that the browser click a particular element on the page.

Parameters

See .

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: download_file

Request a copy of the most recently viewed file in the browser.

Parameters

See .

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:

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 an 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 page's DOM and simplifies it.

Type: print

Request that the browser print the page to a PDF.

Parameters

See .

The following JSON prints the page to a PDF in landscape orientation with a 20px margin.

Type: type

Request that the browser enter a specific piece of text into a field.

Parameters

See .

The following action will type into a particular text field.

The following code will wait up to 10 seconds for the email input field to appear, then type in the provided email.

Type: wait

Request that the browser wait a given amount of time or for a particular item to appear on the page.

Parameters

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.

The following example is a request we've prebuilt to demonstrate Gaffa's capabilities on our You can run this request right now in the .

Gaffa converts web pages to clean markdown, stripping away styling, scripts, and images. This optimises content for LLM applications by reducing credit 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 the article has loaded.

The following example is a request we've prebuilt to show you Gaffa's capabilities on 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 to work out exactly what was shown at a given 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 full-height export screenshot of the page showing all items.

Complete HTTP API documentation for Gaffa. Each endpoint page includes interactive OpenAPI definitions you can try from the docs.

Start with to create and use API keys, then explore the endpoints below.

• — Create and run a browser request

• — Get a browser request by ID

The following endpoint creates a browser request and either runs it synchronously or returns immediately with an ID so you can check its status later.

The following endpoint allows you to query the browser request for your account by ID.

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 describe a data schema for parsing an online PDF to JSON.

The following endpoint allows you to update a data schema by ID.

The following endpoint allows you to list data schemas for your account in a paginated list.

The following endpoint allows you to delete a schema from your account.

This endpoint creates a new site mapping request and returns the result.

This endpoint retrieves information about previous site mapping requests, filterable by id or status

This endpoint retrieves information about a site mapping request.

The following example is a prebuilt request that demonstrates Gaffa's capabilities on our demo site. You can run this request right here in the Gaffa API Playground.

This example demonstrates how to extract tabular data from any webpage without writing a scraper. Gaffa renders the page using a real browser, waits for the table to load, and returns the rows as a clean JSON array, making it perfect for building data pipelines, monitoring dashboards, or feeding structured data into LLM workflows.

API Request

The request below uses the POST endpoint to load a demo table page, waits for the table element to appear, and parses each row into a structured JSON array, using the table's header row as property names.

{
  "url": "https://demo.gaffa.dev/simulate/table?loadTime=1&rowCount=3",
  "proxy_location": null,
  "async": false,
  "max_cache_age": 0,
  "settings": {
    "record_request": false,
    "actions": [
      {
        "type": "wait",
        "selector": "table",
        "timeout": 5000
      },
      {
        "type": "parse_table",
        "selector": "table"
      }
    ]
  }
}

Actions

Response

The parse_table action returns an output URL pointing to the extracted JSON:

{
  "data": {
    "id": "brq_abc123ExampleRequestId",
    "url": "https://demo.gaffa.dev/simulate/table?loadTime=1&rowCount=10",
    "state": "completed",
    "credit_usage": 1,
    "http_status_code": 200,
    "from_cache": false,
    "started_at": "2025-06-09T12:00:00.000Z",
    "completed_at": "2025-06-09T12:00:04.321Z",
    "running_time": "00:00:04.3210000",
    "page_load_time": "00:00:01.1230000",
    "actions": [
      {
        "id": "act_wait001",
        "type": "wait",
        "query": "wait?selector=table&timeout=5000&continue_on_fail=false",
        "timestamp": "2025-06-09T12:00:01.500Z"
      },
      {
        "id": "act_parse001",
        "type": "parse_table",
        "query": "parse_table?selector=table",
        "timestamp": "2025-06-09T12:00:01.600Z",
        "output": "https://storage.gaffa.dev/brq/results/brq_abc123ExampleRequestId/act_parse001_table.json"
      }
    ]
  }
}

Fetching that URL gives you the table rows as a ready-to-use array:

Mapping requests allow you to extract all URLs from a website's sitemap. Gaffa mapping requests have the following useful features:

• Sitemap Discovery: No need to manually find a site's sitemap URL; 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 fetching it again.

• Index Traversal: If the sitemap references other sitemap files, we'll automatically process each one and add its URLs to the list, ensuring the entire hierarchy is captured.

• Aggregation and Duplicate Prevention: In rare cases where the sitemap contains duplicate entries, we'll automatically remove them for you and return all URLs sorted alphabetically.

• Proxies: Gaffa uses its residential proxies behind the scenes to ensure your sitemap retrieval requests 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, you would accept a response returned from the cache; the default is 0, and Gaffa will never return a cached response when 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.

The following example is a request we've prebuilt to show you Gaffa's capabilities on our demo site. You can run this request right now in the Gaffa API Playground.

API Request

{
  "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

Response

Here's a video showing Gaffa filling out the page and waiting for the success modal.

Read More

Read more about screen recording here (TODO).

Type: generate_markdown

The markdown output format exports page data (articles, tables, etc.) in a human- and LLM-readable format, removing unnecessary styling and other "junk" that is only relevant to the site's proper functioning.

Gaffa exports with comments removed and unknown tags ignored.

Type: scroll

Request that the browser scrolls to a certain point on the page or, in the case of pages with infinite scrolling, scrolls for a particular amount of time.

Parameters

See .

Gaffa gives you flexibility over how fast you scroll down the page, which can be really useful to get around restrictions enforced by some sites that 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

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, the page will be monitored for the specified duration 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 halfway 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.

AI assistants like ChatGPT or Claude can generate working code far more effectively when they have accurate, up-to-date context about an API. That's exactly what Gaffa's llms.txt file provides. It provides a concise reference covering Gaffa's endpoints, actions, and code samples that you can drop directly into any AI assistant to get useful, accurate code from the very first prompt.

In this tutorial, we'll walk you through how to use the llms.txt file to build a complete Python script that interacts with the Gaffa API.

Step 1: Get the LLMs.txt File

Download or open the file at https://gaffa.dev/docs/llms.txt. It contains a concise overview of the Gaffa API, including available endpoints, actions, and example payloads.

Step 2: Load It Into Your AI Assistant

Start a new chat with ChatGPT, Claude, or your preferred AI assistant, then paste the full contents of the file into the conversation. This gives the assistant accurate, up-to-date context about the Gaffa API before you ask it anything.

Step 3: Ask the Assistant to Write Your Script

Once the assistant has the context loaded, you can ask it to build scripts for you. For example:

"Write me a Python script that uses Gaffa's browser API to convert a page into Markdown and save the output file locally."

Because the assistant already has the full API context, it can produce accurate code without you needing to explain endpoint structures or payload formats.

Here's an example of the kind of script your AI assistant might generate, based directly on the Gaffa API. It submits a browser request to convert a page to Markdown, polls until the request completes, and downloads the output file.

Run it with:

You'll see the job state printed in your terminal and a downloaded Markdown file saved to an outputs folder.

From here, you can modify the actions list to use other supported operations, such as generate_pdf, screenshot, or extract_text. You can make these changes manually, or simply ask your AI assistant to adapt the script for you. Since it still has the llms.txt context loaded, it can adjust the code to your specific requirements without needing any further explanation.

Type: parse_table

The parse_table action finds a table on a page using a CSS selector and converts it into a structured JSON array with no HTML parsing or post-processing required on your end.

The action reads the table's header row and converts each header into a property name (lowercased, with non-alphanumeric characters replaced by underscores). It then maps each cell value to its corresponding header for every row, returning a clean, ready-to-use JSON array. At the moment, all values are returned as string types.

For cases where you need more control, such as handling merged cells, skipping rows, or applying custom transformations, consider using capture_dom with a parsing library like BeautifulSoup instead.

Parameters

See .

The following request waits up to 1 second for a .large_table element to appear, then parses it into JSON:

Here is an example using Wikipedia's . Wikipedia applies a consistent CSS class to its data tables, making it straightforward to target with a selector:

Notice how column headers like "Country/Territory" and "IMF 2026" are automatically normalized into country_territory and imf_2026. Spaces and special characters are replaced with underscores, and everything is lowercased, so the output is immediately usable without any cleanup:

For a full walkthrough, including a comparison with the capture_dom + BeautifulSoup approach, see our blog post on .

When , you can specify a list of actions you want us to perform on the requested web page. These actions conform to the following format:

All actions have the following parameters:

The following example is a request we've prebuilt to show you Gaffa's capabilities on our You can run this request right now in the .

Gaffa automates infinite scrolling on dynamic pages, such as 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 to open the demo site in the e-commerce site simulator, featuring 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)

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 here in the Gaffa API Playground.

This example demonstrates how to extract data from PDF documents. Gaffa downloads the PDF and uses AI to intelligently parse the content according to your schema, making it perfect for building research databases, citation managers, or literature review tools.

This feature currently works for online PDFs.

API Request

The request below uses the POST endpoint to download a demo research paper from the hosted PDFs, wait for it to load, and then parse the first page to extract author information and paper metadata.

Actions

Response

The parsed data is returned as a structured JSON object matching your schema:

The settings object in your browser request allows you to configure various aspects of how your automation behaves. Below are all the available settings parameters you can use.

Screen Recording

Parameter: 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.

Example:

{
  "url": "https://example.com",
  "settings": {
    "record_request": true,
    "actions": [...]
  }
}

Parameter: max_media_bandwidth (integer or null)

If you're using Gaffa on a site with lots of images and videos but are more interested in the text data on the page, you can cap how much media content a page loads using the max_media_bandwidth setting. This makes your automation faster and prevents spending credits on data you aren't interested in.

You can set max_media_bandwidth in three ways:

• "max_media_bandwidth": 0 — Block all images and videos completely

• "max_media_bandwidth": 5 — Cap media downloads at 5MB (or any number you specify)

• "max_media_bandwidth": null — No limit (default)

When the max_media_bandwidth value is set, Gaffa monitors the data being downloaded by the page. When the downloaded media exceeds the specified MB limit, any further downloads of images or videos will be cancelled.

This setting is particularly useful for:

• Scraping news articles for text only — Extract headlines and article content without downloading thumbnails

• E-commerce price monitoring — Track product prices and descriptions without loading product images

• Extracting reviews and text content — Capture customer reviews without profile pictures

Start with max_media_bandwidth: 0 for maximum savings, then adjust upward only if you encounter issues with specific sites. Setting a value of 0 will cause no images to load, which works well on most sites, but on some could lead to the site thinking you are using an ad blocker.

Example:

Learn more: See our detailed on optimizing browser requests with max_media_bandwidth, including real-world testing, use cases, and best practices.

Parameter: time_limit (integer)

Using the time_limit setting caps the maximum running time of the request in milliseconds. If this time expires, all incomplete actions will be canceled, and the request will return an error.

This cap must be less than the maximum request runtime specified in your plan; if not set, it defaults to that value.

Example:

Parameter: block_ads (boolean)

If you are automating or scraping content on ad-heavy websites, third-party ad network requests can slow down your page load significantly, even though you don't need them. By enabling block_ads , Gaffa intercepts and immediately aborts requests to known ad-serving domains before they load, reducing page load times without affecting the core page content.

You can set block_ads in two ways:

• "block_ads": false — Ad blocking disabled (default)

• "block_ads": true — Ad blocking enabled

Example:

Parameter: actions (array)

The actions parameter defines the specific tasks you want Gaffa to perform on the page once it loads. Actions are executed in the order they appear in your array and can include tasks such as waiting for elements, capturing screenshots, generating Markdown, printing to PDF, and more.

We support different types of actions, each designed for specific automation needs. .

Example:

Here's a browser request using multiple settings parameters:

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.

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.

1. Install Python 3.10 or newer.

2. Create a virtual environment

1. Install the required libraries

1. 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 page's main content and convert it to markdown.

Now that we have the markdown content, we can ask questions about it using the OpenAI API. The function below takes markdown content and a question as input, then 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 lets users enter a URL and ask questions about its 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 web page URL, and it will fetch the markdown content and let you ask questions about it.

Automating the collection of images from a website can save hours of manual work. Whether you're a marketer building a competitor analysis, a developer creating a dataset, or an archiver preserving digital content, doing this manually is tedious and error-prone.

In this tutorial, you'll learn how to use Gaffa's powerful Mapping and Browser Requests endpoints to automatically find, extract, and download every image from a website in a short Python script. We'll leverage features like the capture_dom action, intelligent sitemap parsing, and the download_file action to handle this efficiently and responsibly.

By the end of this guide, you'll be able to:

• Use Gaffa's site/map endpoint to discover every page on a site.

• Render each page with a headless browser to capture its full DOM.

• Parse and download all images using Gaffa's action with residential proxies

• Run the process at scale with built-in proxy rotation and caching.

• Python 3.10+ is installed on your machine.

• A Gaffa API key. and get your API key from the dashboard.

• Basic familiarity with the command line.

• Handles JavaScript-Rendered Content: Unlike simple HTTP scrapers, Gaffa uses a real browser, so it captures anything that is lazy-loaded by JavaScript.

• Stealth Downloading with Residential Proxies: The download_file action uses real browsers and proxies, making your requests appear as legitimate user traffic.

• Intelligent Caching: With `max_cache_age` set to 24 hours, repeated requests for the same image are served from cache, reducing load on target servers and improving efficiency.

This technique is useful for far more than just downloading pictures. Here are a few ideas:

• Competitive Analysis: Analyze competitors' product photography styles using real browsers.

• AI/ML Datasets: Build large, curated image datasets for training computer vision models using ethically sourced images.

• Website Migration & Audits: Download all assets from an old site before a migration while minimizing server impact through caching.

The full script is available on our .

Ready to automate your image collection with enterprise-grade infrastructure? and start building today.

The following example is a request we've pre-built to show you Gaffa's capabilities against our . You can run this request right here in the .

This example demonstrates how to extract structured information from HTML forms on web pages. Gaffa uses AI to identify form elements and their properties, making it perfect for form automation, testing, accessibility audits, or building form-filling assistants.

The request below uses the to open the demo form page, wait for the modal to appear, and then parse the visible form to extract all field information, including labels, input names, placeholders, and dropdown options.

The parsed form data is returned as a structured JSON object:

Web forms are some of the most common and repetitive elements that users often interact with as developers. Whether you are collecting data, testing user flows, or even building other automation systems.

In this guide, you'll learn how to use pase_json action to extract the structure of a web form and then automatically fill and submit it using Gaffa's browser automation features.

By the end of this guide, you will be able to:

• Extract structured form data (labels, input names, required fields, and placeholders) using parse_json

• Define and use schemas to reliably understand page structure

• Build a simple interactive CLI that collects user input

• Automatically fill and submit a web form using Gaffa browser actions

1. Install Python 3.10 or newer.

2. Create a virtual environment

1. Install the required libraries

1. Get your key and store it as an environment variable:

1. Install the required library

In this tutorial, you'll create a Python script that:

• Extracts form fields - Uses Parse JSON to analyze any web form and identify all input fields.

• Collects user input - Prompts the user in the terminal to provide values for each field.

• Submits the form - Automatically fills and submits the form using Gaffa's browser automation.

By the end, you'll have a working form automation tool that can be adapted for countless use cases.

Create a new directory and Python file.

Create a file called form_filler.py (or any name that works for you) and add your configuration.

Replace your_api_key_here with your actual Gaffa API key from the .

In the code below, you define a function that takes a form URL as input and makes a POST request to the Gaffa API.

The request uses two actions: first, a wait action ensures the form element is fully loaded on the page, then the parse_json action that uses AI to intelligently analyze the form structure and extract all input fields along with their properties (labels, names, types, placeholders, and required status). The AI understands the context of the form and returns structured JSON data that we can easily work with.

Next, you need to define a function that takes the extracted form data and interacts with the user in the terminal. The function will display the form title and then loop through each field, prompting the user to fill in the value.

For each field in the form, a label and a required marker, if applicable, are shown. The function ensures that the required fields are not left empty and allows users to skip optional fields by pressing enter. All the user's input is collected into a dictionary where the keys are the field names and the values are what the user entered.

You need a function that will take the form URL and the user's input values, then submit the form to Gaffa's browser automation. The function will build a list of actions.

First, it waits for the form to be ready, then creates a type action for each field to enter the user's value into the corresponding input element using CSS selectors. Lastly, it adds a click action to submit the form and a capture_screenshot action to take a full-screen image of the results.

The function makes a POST request with all these actions and returns the response, which includes the screenshot URL if successful.

Having defined the functions, we can now create a simple command-line interface that allows users to interact with the form.

The full script is available to download from the .

To run the script, simply execute it in your terminal: