diff --git a/docs/examples/code_examples/fill_and_submit_web_form_automated.py b/docs/examples/code_examples/fill_and_submit_web_form_automated.py
new file mode 100644
index 0000000000..844b0d9fe3
--- /dev/null
+++ b/docs/examples/code_examples/fill_and_submit_web_form_automated.py
@@ -0,0 +1,39 @@
+import asyncio
+
+from crawlee.crawlers import ParselCrawler, ParselCrawlingContext
+
+
+async def main() -> None:
+    crawler = ParselCrawler()
+
+    # Fill in the form on the page and enqueue its submission.
+    @crawler.router.default_handler
+    async def request_handler(context: ParselCrawlingContext) -> None:
+        context.log.info(f'Filling in the form on {context.request.url} ...')
+        requests = await context.extract_form_requests(
+            fields={
+                'custname': 'John Doe',
+                'custtel': '1234567890',
+                'custemail': 'johndoe@example.com',
+                'size': 'large',
+                'topping': ['bacon', 'cheese', 'mushroom'],
+                'delivery': '13:00',
+                'comments': 'Please ring the doorbell upon arrival.',
+            },
+            label='form-result',
+        )
+        await context.add_requests(requests)
+
+    # Process the response to the form submission.
+    @crawler.router.handler('form-result')
+    async def form_result_handler(context: ParselCrawlingContext) -> None:
+        context.log.info(f'Processing {context.request.url} ...')
+        response = (await context.http_response.read()).decode('utf-8')
+        context.log.info(f'Response: {response}')  # To see the response in the logs.
+
+    # Run the crawler with the page containing the form.
+    await crawler.run(['https://httpbin.org/forms/post'])
+
+
+if __name__ == '__main__':
+    asyncio.run(main())
diff --git a/docs/examples/fill_and_submit_web_form.mdx b/docs/examples/fill_and_submit_web_form.mdx
index bda46c1d97..e81af4623f 100644
--- a/docs/examples/fill_and_submit_web_form.mdx
+++ b/docs/examples/fill_and_submit_web_form.mdx
@@ -10,8 +10,9 @@ import RunnableCodeBlock from '@site/src/components/RunnableCodeBlock';
 
 import RequestExample from '!!raw-loader!roa-loader!./code_examples/fill_and_submit_web_form_request.py';
 import CrawlerExample from '!!raw-loader!roa-loader!./code_examples/fill_and_submit_web_form_crawler.py';
+import AutomatedExample from '!!raw-loader!roa-loader!./code_examples/fill_and_submit_web_form_automated.py';
 
-This example demonstrates how to fill and submit a web form using the <ApiLink to="class/HttpCrawler">`HttpCrawler`</ApiLink> crawler. The same approach applies to any crawler that inherits from it, such as the <ApiLink to="class/BeautifulSoupCrawler">`BeautifulSoupCrawler`</ApiLink> or <ApiLink to="class/ParselCrawler">`ParselCrawler`</ApiLink>.
+This example demonstrates how to fill and submit a web form using the <ApiLink to="class/HttpCrawler">`HttpCrawler`</ApiLink> crawler. The same approach applies to any crawler that inherits from it, such as the <ApiLink to="class/BeautifulSoupCrawler">`BeautifulSoupCrawler`</ApiLink> or <ApiLink to="class/ParselCrawler">`ParselCrawler`</ApiLink>. These two crawlers can also [fill in the form automatically](#fill-in-the-form-automatically).
 
 We are going to use the [httpbin.org](https://httpbin.org) website to demonstrate how it works.
 
@@ -118,3 +119,21 @@ Finally, run your crawler. Your logs should show something like this:
 ```
 
 This log output confirms that the crawler successfully submitted the form and processed the response. Congratulations! You have successfully filled and submitted a web form using the <ApiLink to="class/HttpCrawler">`HttpCrawler`</ApiLink>.
+
+## Fill in the form automatically
+
+The <ApiLink to="class/ParselCrawler">`ParselCrawler`</ApiLink> and <ApiLink to="class/BeautifulSoupCrawler">`BeautifulSoupCrawler`</ApiLink> can build the form request for you. Their crawling contexts provide the <ApiLink to="class/ParselCrawlingContext#extract_form_requests">`extract_form_requests`</ApiLink> helper, which reads the form from the page, fills in your values and returns a list with the request that submits it the way a browser does. The action URL, the method and the encoding come from the form itself, so you only need the field names from [Investigate the form fields](#investigate-the-form-fields).
+
+The crawler below opens the page with the form. The default handler fills in the form with the `fields` argument and enqueues the submission with a label. A separate handler for that label processes the response.
+
+<RunnableCodeBlock className="language-python" language="python">
+    {AutomatedExample}
+</RunnableCodeBlock>
+
+Note that:
+
+- `fields` replaces the values of the listed fields and adds the ones the form doesn't have. A list submits the field once per value, as with the `topping` checkboxes.
+- Fields you don't list keep the values from the page, so hidden inputs such as CSRF tokens are submitted as they are. A CSRF token is tied to the session cookie, so pass `session_id=context.session.id` to send the form in the same session. The request also carries the `Referer` and `Origin` headers a browser sends, which some CSRF checks require.
+- On a page with several forms, the helper submits the one sharing the most field names with `fields`, or the first one if none shares any. It skips forms that can't be submitted, for example because their action is JavaScript, but never falls back to a form sharing fewer names, so the list can be empty. To pick a form yourself, pass a CSS selector such as `selector='#order'`. To submit each form, pass `all_forms=True`. Then `fields` only replaces the fields each form has.
+- The first enabled submit button of the form is clicked by default, and a form without one is submitted anyway. Use the `click` argument to pick another button by its attributes, even a disabled one, or to submit without one.
+- The page decides where its form is sent. To enqueue only requests to the same host, call `context.add_requests(requests, strategy='same-hostname')`.
diff --git a/docs/guides/code_examples/scrapy_migration/crawlee_post.py b/docs/guides/code_examples/scrapy_migration/crawlee_post.py
index 2f332426ef..b97a77552e 100644
--- a/docs/guides/code_examples/scrapy_migration/crawlee_post.py
+++ b/docs/guides/code_examples/scrapy_migration/crawlee_post.py
@@ -1,7 +1,5 @@
 import asyncio
-from urllib.parse import urlencode
 
-from crawlee import Request
 from crawlee.crawlers import ParselCrawler, ParselCrawlingContext
 
 
@@ -14,34 +12,16 @@ async def login_page(context: ParselCrawlingContext) -> None:
         if not context.session:
             raise RuntimeError('Session not found')
 
-        token = context.selector.css('input[name="csrf_token"]::attr(value)').get()
-
-        # The CSRF token is required for the POST to succeed. If it's missing,
-        # the login will fail.
-        if not token:
-            raise RuntimeError('CSRF token not found')
-
-        form = {'csrf_token': token, 'username': 'user', 'password': 'pass'}
-
         # highlight-start
-        # Crawlee's `payload` is the raw request body, so encode the fields yourself
-        # and set the `Content-Type`. Scrapy's `FormRequest` does both for you.
-        await context.add_requests(
-            [
-                Request.from_url(
-                    'https://quotes.toscrape.com/login',
-                    method='POST',
-                    payload=urlencode(form),
-                    headers={'content-type': 'application/x-www-form-urlencoded'},
-                    label='after-login',
-                    # Bind the POST to the same session so its CSRF cookie matches.
-                    session_id=context.session.id,
-                    # The POST shares the GET's URL. Include the method and payload
-                    # in the unique key, or the queue drops it as a duplicate.
-                    use_extended_unique_key=True,
-                )
-            ]
+        # Like Scrapy's `FormRequest.from_response`, the helper keeps the hidden
+        # `csrf_token` field, encodes the data and sets the `Content-Type` header.
+        requests = await context.extract_form_requests(
+            fields={'username': 'user', 'password': 'pass'},
+            label='after-login',
+            # Bind the POST to the same session so its CSRF cookie matches.
+            session_id=context.session.id,
         )
+        await context.add_requests(requests)
         # highlight-end
 
     @crawler.router.handler('after-login')
diff --git a/docs/guides/scrapy_migration.mdx b/docs/guides/scrapy_migration.mdx
index 5acbfa3824..a5e4c29a9e 100644
--- a/docs/guides/scrapy_migration.mdx
+++ b/docs/guides/scrapy_migration.mdx
@@ -80,7 +80,7 @@ Both frameworks give you a request scheduler, filtering of duplicate requests, r
 | `response.follow()` / `yield Request(...)` | <ApiLink to="class/EnqueueLinksFunction">`enqueue_links`</ApiLink> / <ApiLink to="class/AddRequestsFunction">`add_requests`</ApiLink> |
 | `dont_filter=True` | <ApiLink to="class/Request#from_url">`Request.from_url(always_enqueue=True)`</ApiLink> |
 | `allowed_domains` | <ApiLink to="class/EnqueueLinksFunction">`enqueue_links(strategy=...)`</ApiLink> |
-| `scrapy.FormRequest` | <ApiLink to="class/Request#from_url">`Request.from_url(method='POST', payload=...)`</ApiLink> |
+| `scrapy.FormRequest` | <ApiLink to="class/Request#from_url">`Request.from_url(method='POST', payload=...)`</ApiLink> / <ApiLink to="class/BeautifulSoupCrawlingContext#extract_form_requests">`context.extract_form_requests(...)`</ApiLink> |
 | Item pipelines | <ApiLink to="class/Dataset">`Dataset`</ApiLink> |
 | Downloader / spider middlewares | <ApiLink to="class/Router#use">`router.use()`</ApiLink>, navigation hooks, <ApiLink to="class/HttpClient">HTTP clients</ApiLink> |
 | `settings.py` | <ApiLink to="class/Configuration">`Configuration`</ApiLink> + crawler arguments |
@@ -263,7 +263,7 @@ Scrapy retries failed requests with `RetryMiddleware` and reports terminal failu
 
 ## Forms and login
 
-Scrapy submits forms with `FormRequest`, which encodes `formdata` as `form-urlencoded` and sets the header for you. Crawlee's <ApiLink to="class/Request#from_url">`payload`</ApiLink> takes the raw request body, so encode the fields yourself with `urllib.parse.urlencode` and set the `Content-Type` through `headers=`. For a full login flow with session reuse, see the [Logging in with a crawler guide](./logging-in-with-a-crawler).
+Scrapy submits forms with `FormRequest.from_response`, which reads the form from the page, keeps its hidden fields and encodes the data for you. Crawlee's <ApiLink to="class/ParselCrawlingContext#extract_form_requests">`extract_form_requests`</ApiLink> helper does the same in the <ApiLink to="class/ParselCrawler">`ParselCrawler`</ApiLink> and <ApiLink to="class/BeautifulSoupCrawler">`BeautifulSoupCrawler`</ApiLink>. Pass your values in `fields` and request options such as `label` or `session_id` as keyword arguments. Like `from_response`, it submits a single form. Scrapy takes the first form by default, while the helper prefers the one sharing the most field names with `fields`. It returns a list, which is empty when no form matches, so enqueue it with `add_requests`. For a plain `FormRequest` that doesn't come from a form on the page, use <ApiLink to="class/Request#from_url">`Request.from_url`</ApiLink>. Its `payload` is the raw request body, so encode the fields with `urllib.parse.urlencode` and set the `Content-Type` through `headers=`. For a full login flow with session reuse, see the [Logging in with a crawler guide](./logging-in-with-a-crawler).
 
 <Tabs groupId="scrapy-migration-login">
     <TabItem value="scrapy" label="Scrapy">
diff --git a/src/crawlee/_utils/html.py b/src/crawlee/_utils/html.py
index 5b357f312a..511a55e800 100644
--- a/src/crawlee/_utils/html.py
+++ b/src/crawlee/_utils/html.py
@@ -4,8 +4,24 @@
 
 import codecs
 import re
+from typing import TYPE_CHECKING, NamedTuple, TypedDict
+from urllib.parse import urlencode, urlsplit
 
+from yarl import URL
+
+from crawlee._request import Request
+from crawlee._types import HttpHeaders
+from crawlee._utils.crypto import compute_short_hash
 from crawlee._utils.http import parse_content_type_charset
+from crawlee._utils.urls import convert_to_absolute_url, is_url_absolute, validate_http_url
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from lxml.html import HtmlElement
+    from typing_extensions import NotRequired, Unpack
+
+    from crawlee._types import JsonSerializable
 
 # Matches the `encoding` of an XML declaration, which XHTML pages may use instead of a `<meta>` tag.
 _XML_ENCODING_PATTERN = re.compile(rb'^\s*<\?xml[^>]*\sencoding\s*=\s*["\']([a-z0-9_:.+-]+)', re.IGNORECASE)
@@ -90,6 +106,68 @@
 
 _ENCODING_BY_LABEL = {label: codec for codec, labels in _WHATWG_ENCODING_LABELS.items() for label in labels.split()}
 
+_FIELD_TAGS = ('input', 'button', 'select', 'textarea')
+_BUTTON_INPUT_TYPES = ('submit', 'image', 'reset', 'button')
+
+# Browsers cut a longer referrer down to the origin.
+_MAX_REFERRER_LENGTH = 4096
+
+_LINE_BREAK_PATTERN = re.compile(r'\r\n|\r|\n')
+
+# Browsers collapse only ASCII whitespace in an option text, keeping non-breaking spaces.
+_ASCII_WHITESPACE_PATTERN = re.compile(r'[ \t\n\f\r]+')
+
+_MULTIPART_NAME_ESCAPES = str.maketrans({'"': '%22', '\r': '%0D', '\n': '%0A'})
+
+# The URL parser strips C0 controls and spaces around a URL, but no other whitespace.
+_URL_STRIP_CHARS = ''.join(map(chr, range(0x21)))
+
+_COLOR_PATTERN = re.compile(r'#[0-9a-fA-F]{6}')
+_FLOAT_PATTERN = re.compile(r'-?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][-+]?\d+)?', re.ASCII)
+
+
+class FormRequestOptions(TypedDict):
+    """Options for the `Request` created from a form.
+
+    Mirrors `RequestOptions` without the URL, method and payload, which come from the form, without `id` and
+    `unique_key`, which can't be shared by several forms, and without `enqueue_strategy`, which enqueuing sets.
+    """
+
+    label: NotRequired[str | None]
+    """A label routing the request to a specific handler."""
+
+    headers: NotRequired[HttpHeaders | dict[str, str] | None]
+    """HTTP headers of the request, replacing those the form sets, like `Content-Type` or `Referer`."""
+
+    session_id: NotRequired[str | None]
+    """ID of the `Session` the request is bound to."""
+
+    keep_url_fragment: NotRequired[bool]
+    """Whether the URL fragment counts towards the unique key of the request."""
+
+    use_extended_unique_key: NotRequired[bool]
+    """Whether the method and payload count towards the unique key. Defaults to `True` for POST forms."""
+
+    always_enqueue: NotRequired[bool]
+    """Whether to enqueue the request even if it's already in the queue."""
+
+    user_data: NotRequired[Mapping[str, JsonSerializable]]
+    """Custom data stored with the request."""
+
+    no_retry: NotRequired[bool]
+    """Whether to skip retrying the request if it fails."""
+
+    max_retries: NotRequired[int | None]
+    """The maximum number of retries of the request."""
+
+
+class _Field(NamedTuple):
+    """A single entry the form submits."""
+
+    name: str
+    value: str
+    is_file: bool = False
+
 
 def get_declared_html_encoding(body: bytes, content_type: str | None) -> str | None:
     """Get the Python codec for the encoding an HTML response body declares.
@@ -110,7 +188,7 @@ def get_declared_html_encoding(body: bytes, content_type: str | None) -> str | N
             return encoding
 
     header_charset = parse_content_type_charset(content_type)
-    return _resolve_encoding(header_charset) or _find_declared_encoding(body)
+    return resolve_encoding(header_charset) or _find_declared_encoding(body)
 
 
 def decode_html_body(body: bytes, encoding: str) -> str:
@@ -125,18 +203,99 @@ def decode_html_body(body: bytes, encoding: str) -> str:
     return body.decode(encoding, 'replace').removeprefix('\ufeff')
 
 
-def _resolve_encoding(label: str | None) -> str | None:
+def resolve_encoding(label: str | None) -> str | None:
     """Get the Python codec for a WHATWG encoding label, or `None` if browsers don't know the label."""
     if not label:
         return None
     return _ENCODING_BY_LABEL.get(label.lower())
 
 
+def strip_html_comments(body: bytes) -> bytes:
+    """Remove the HTML comments from the body, so a commented-out declaration doesn't count."""
+    return _HTML_COMMENT_PATTERN.sub(b'', body)
+
+
+def forms_to_requests(
+    forms: Sequence[HtmlElement],
+    page_url: str,
+    page_encoding: str,
+    *,
+    fields: Mapping[str, str | Sequence[str] | None] | None = None,
+    click: bool | Mapping[str, str] = True,
+    all_forms: bool = False,
+    **kwargs: Unpack[FormRequestOptions],
+) -> list[Request]:
+    """Create a `Request` submitting one of the forms, or each of them, the way a browser does.
+
+    Args:
+        forms: The form elements, each within the lxml tree of the whole page.
+        page_url: The URL of the page, which forms without an action submit to and the `Referer` comes from.
+        page_encoding: The Python codec the page was decoded with, which forms submit in by default.
+        fields: Field values to submit, see `extract_form_requests` of the crawling contexts.
+        click: The submit button to click, see `extract_form_requests`.
+        all_forms: Whether to submit each form, filling in only the fields it has, see `extract_form_requests`.
+        **kwargs: Additional options passed to `Request.from_url`.
+    """
+    if not forms:
+        return []
+
+    root = forms[0].getroottree().getroot()
+    base = next(iter(root.xpath('//base[@href][not(ancestor::template)]')), None)
+    try:
+        base_url = convert_to_absolute_url(page_url, '' if base is None else base.get('href').strip(_URL_STRIP_CHARS))
+    except ValueError:
+        base_url = page_url
+
+    # Browsers keep the contents of a `<template>` out of the page, so its elements don't take part.
+    inert = {element for template in root.iter('template') for element in template.iter('form', *_FIELD_TAGS)}
+    forms = [form for form in forms if form not in inert]
+    if not forms:
+        return []
+    page_elements = [element for element in root.iter(*_FIELD_TAGS) if element not in inert]
+    elements_by_form = _elements_by_form(root, page_elements)
+    disabled = _disabled_elements(root, page_elements)
+
+    if not all_forms:
+        # The form sharing the most field names with `fields` is the one to fill in, and ties keep document order.
+        # Forms sharing fewer names never get the values, even if the best one can't be submitted.
+        wanted = set(fields or ())
+        shared = {form: len(wanted & _field_names(elements_by_form.get(form, []))) for form in forms}
+        most_shared = max(shared.values())
+        forms = [form for form in forms if shared[form] == most_shared]
+
+    requests = []
+    for form in forms:
+        elements = elements_by_form.get(form, [])
+        form_fields = fields
+        if all_forms and fields:
+            # Values meant for one form don't spread to the others, like credentials into a search form.
+            names = _field_names(elements)
+            form_fields = {name: value for name, value in fields.items() if name in names}
+
+        request = _form_to_request(
+            form,
+            elements,
+            page_url=page_url,
+            base_url=base_url,
+            page_encoding=page_encoding,
+            disabled=disabled,
+            fields=form_fields,
+            click=click,
+            **kwargs,
+        )
+        if request is None:
+            continue
+        requests.append(request)
+        if not all_forms:
+            break
+    return requests
+
+
 def _find_declared_encoding(body: bytes) -> str | None:
     """Find the encoding declared by an XML declaration or a `<meta>` tag near the start of the body."""
-    prescan = _HTML_COMMENT_PATTERN.sub(b'', body[:_PRESCAN_BYTES])
+    prescan = strip_html_comments(body[:_PRESCAN_BYTES])
     xml_match = _XML_ENCODING_PATTERN.match(prescan)
-    xml_encoding = _resolve_encoding(xml_match.group(1).decode('ascii')) if xml_match else None
+    xml_encoding = resolve_encoding(xml_match.group(1).decode('ascii')) if xml_match else None
     encoding = xml_encoding or _find_meta_encoding(prescan)
     # A declaration readable as ASCII rules out UTF-16, so browsers read such pages as UTF-8.
     return 'utf-8' if encoding and encoding.startswith('utf-16') else encoding
@@ -161,7 +320,321 @@ def _find_meta_encoding(prescan: bytes) -> str | None:
         else:
             continue
 
-        encoding = _resolve_encoding(label)
+        encoding = resolve_encoding(label)
         if encoding:
             return encoding
     return None
+
+
+def _elements_by_form(root: HtmlElement, elements: list[HtmlElement]) -> dict[HtmlElement, list[HtmlElement]]:
+    """Group the fields and buttons of the page by the form they belong to, in document order."""
+    # Walking each form avoids an ancestor walk per field.
+    enclosing_form: dict[HtmlElement, HtmlElement] = {}
+    for form in root.iter('form'):
+        enclosing_form.update(dict.fromkeys(form.iter(*_FIELD_TAGS), form))
+
+    # The first element with a given ID wins, as in `getElementById`. Only the `form` attribute needs them.
+    elements_by_id: dict[str, HtmlElement] = {}
+    if any(element.get('form') is not None for element in elements):
+        for element in root.xpath('//*[@id!=""][not(ancestor::template)]'):
+            elements_by_id.setdefault(element.get('id'), element)
+
+    elements_by_form: dict[HtmlElement, list[HtmlElement]] = {}
+    for element in elements:
+        form_id = element.get('form')
+        owner = enclosing_form.get(element) if form_id is None else elements_by_id.get(form_id)
+        if owner is not None and owner.tag == 'form':
+            elements_by_form.setdefault(owner, []).append(element)
+    return elements_by_form
+
+
+def _disabled_elements(root: HtmlElement, elements: list[HtmlElement]) -> set[HtmlElement]:
+    """Find the disabled fields and buttons, including those inside a disabled `<fieldset>`."""
+    disabled = {element for element in elements if 'disabled' in element.attrib}
+    for fieldset in root.iter('fieldset'):
+        # A fieldset inside a disabled one is already covered, so each element is visited once.
+        if 'disabled' in fieldset.attrib and fieldset not in disabled:
+            # The contents of the first `<legend>` child stay enabled.
+            legend = next((child for child in fieldset if child.tag == 'legend'), None)
+            exempt = set() if legend is None else set(legend.iter('fieldset', *_FIELD_TAGS))
+            disabled.update(element for element in fieldset.iter('fieldset', *_FIELD_TAGS) if element not in exempt)
+    return disabled
+
+
+def _field_names(elements: list[HtmlElement]) -> set[str]:
+    """Get the names of the given fields and buttons."""
+    return {name for element in elements if (name := element.get('name'))}
+
+
+def _form_to_request(
+    form: HtmlElement,
+    elements: list[HtmlElement],
+    *,
+    page_url: str,
+    base_url: str,
+    page_encoding: str,
+    disabled: set[HtmlElement],
+    fields: Mapping[str, str | Sequence[str] | None] | None,
+    click: bool | Mapping[str, str],
+    **kwargs: Unpack[FormRequestOptions],
+) -> Request | None:
+    """Create a `Request` submitting a single form, or `None` if a browser wouldn't send one."""
+    button = None
+    if click is not False:
+        button = _find_clickable(elements, {} if click is True else click, disabled)
+        if click is not True and button is None:
+            # Pages often enable a button with JavaScript, so a disabled one matching `click` is clicked too.
+            button = _find_clickable(elements, click, set())
+            if button is None:
+                return None
+
+    method = (_submission_attribute(form, button, 'method') or 'get').upper()
+    enctype = _submission_attribute(form, button, 'enctype').lower()
+    action = _submission_attribute(form, button, 'action')
+
+    # A dialog form only closes its `<dialog>` on the client.
+    if method == 'DIALOG':
+        return None
+
+    url = _resolve_action(page_url, base_url, action)
+    if url is None:
+        return None
+
+    entries = _collect_fields(elements, button, fields, disabled)
+    encoding = _form_encoding(form, page_encoding)
+    # CSRF checks may require the `Referer` or `Origin` a browser sends. Headers passed in `headers` win.
+    form_headers = _referrer_headers(page_url, url, method)
+
+    if method != 'POST':
+        query = urlencode(
+            [(entry.name, entry.value) for entry in entries], encoding=encoding, errors='xmlcharrefreplace'
+        )
+        kwargs['headers'] = HttpHeaders(form_headers) | HttpHeaders(kwargs.get('headers') or {})
+        return Request.from_url(urlsplit(url)._replace(query=query).geturl(), method='GET', **kwargs)
+
+    payload, form_headers['Content-Type'] = _encode_body(entries, enctype, encoding)
+    kwargs['headers'] = HttpHeaders(form_headers) | HttpHeaders(kwargs.get('headers') or {})
+    kwargs.setdefault('use_extended_unique_key', True)
+    return Request.from_url(url, method='POST', payload=payload, **kwargs)
+
+
+def _find_clickable(
+    elements: list[HtmlElement], attributes: Mapping[str, str], disabled: set[HtmlElement]
+) -> HtmlElement | None:
+    """Find the first submit button having all the given attributes, skipping the `disabled` ones."""
+    for element in elements:
+        if not _is_submit_button(element) or element in disabled:
+            continue
+        if all(element.get(key) == value for key, value in attributes.items()):
+            return element
+    return None
+
+
+def _is_submit_button(element: HtmlElement) -> bool:
+    """Check whether the element submits the form when clicked."""
+    button_type = element.get('type', '').lower()
+    if element.tag == 'button':
+        # A missing or unknown type makes a submit button.
+        return button_type not in ('reset', 'button')
+    if element.tag == 'input':
+        return button_type in ('submit', 'image')
+    return False
+
+
+def _submission_attribute(form: HtmlElement, button: HtmlElement | None, name: str) -> str:
+    """Get a form attribute like `action`, which the clicked button can override with its `form*` counterpart."""
+    # A present but empty override still wins, like `formaction=""` submitting to the page URL.
+    if button is not None and (button_value := button.get(f'form{name}')) is not None:
+        return button_value
+    return form.get(name) or ''
+
+
+def _resolve_action(page_url: str, base_url: str, action: str) -> str | None:
+    """Resolve the form action to an absolute URL, or `None` if it isn't a valid HTTP(S) URL."""
+    if not action:
+        return page_url
+
+    try:
+        url = convert_to_absolute_url(base_url, action.strip(_URL_STRIP_CHARS))
+        validate_http_url(url)
+    except ValueError:
+        return None
+    # `validate_http_url` accepts a URL without a host, like `http:x` resolved against an HTTPS page.
+    return url if is_url_absolute(url) else None
+
+
+def _collect_fields(
+    elements: list[HtmlElement],
+    button: HtmlElement | None,
+    fields: Mapping[str, str | Sequence[str] | None] | None,
+    disabled: set[HtmlElement],
+) -> list[_Field]:
+    """Collect the entries the form submits: its fields, the clicked button and the `fields` overrides."""
+    # Only one radio button of a group is checked, the last one in the markup.
+    checked_radios = {element.get('name'): element for element in elements if _is_radio(element) and element.checked}
+
+    entries: list[_Field] = []
+    for element in elements:
+        if element is button:
+            entries.extend(_button_fields(button))
+            continue
+        if not element.get('name') or element in disabled:
+            continue
+        if _is_radio(element) and checked_radios.get(element.get('name')) is not element:
+            continue
+        entries.extend(_element_fields(element))
+
+    # Browsers submit every line break as CRLF.
+    return [
+        _Field(_LINE_BREAK_PATTERN.sub('\r\n', entry.name), _LINE_BREAK_PATTERN.sub('\r\n', entry.value), entry.is_file)
+        for entry in _apply_fields(entries, fields or {})
+    ]
+
+
+def _is_radio(element: HtmlElement) -> bool:
+    """Check whether the element is a radio button."""
+    return element.tag == 'input' and element.type == 'radio'
+
+
+def _button_fields(button: HtmlElement) -> list[_Field]:
+    """Get the entries the clicked button adds."""
+    name = button.get('name')
+
+    # An image button sends the click coordinates instead of its value.
+    if button.tag == 'input' and button.get('type', '').lower() == 'image':
+        prefix = f'{name}.' if name else ''
+        return [_Field(f'{prefix}x', '0'), _Field(f'{prefix}y', '0')]
+
+    if name:
+        return [_Field(name, button.get('value', ''))]
+    return []
+
+
+def _element_fields(element: HtmlElement) -> list[_Field]:
+    """Get the entries a single enabled, named field submits."""
+    name = element.get('name')
+
+    if element.tag == 'select':
+        return [_Field(name, value) for value in _select_values(element)]
+
+    if element.tag == 'textarea':
+        # Browsers drop the newline right after `<textarea>`, lxml keeps it.
+        return [_Field(name, element.value.removeprefix('\n'))]
+
+    # Buttons submit only when clicked, see `_button_fields`.
+    if element.tag != 'input' or element.type in _BUTTON_INPUT_TYPES:
+        return []
+
+    if element.type == 'file':
+        return [_Field(name, '', is_file=True)]
+
+    if element.checkable and not element.checked:
+        return []
+
+    # lxml reports `on` for a checkbox or radio button with an empty `value`, which browsers submit as is.
+    value = element.get('value', 'on' if element.checkable else '')
+    # Browsers replace an invalid color with black and an invalid number with an empty string, strip line breaks from
+    # the value of a text-like input, and also surrounding whitespace from an email or URL.
+    if element.type == 'color':
+        value = value.lower() if _COLOR_PATTERN.fullmatch(value) else '#000000'
+    elif element.type == 'number':
+        value = value if _FLOAT_PATTERN.fullmatch(value) else ''
+    elif element.type not in ('hidden', 'checkbox', 'radio'):
+        value = value.replace('\r', '').replace('\n', '')
+        if element.type in ('email', 'url'):
+            value = value.strip(' \t\n\f\r')
+    return [_Field(name, value)]
+
+
+def _select_values(select: HtmlElement) -> list[str]:
+    """Get the values of the selected options of a `<select>`, which browsers submit unless disabled."""
+    options = list(select.iter('option'))
+    enabled = {
+        option
+        for option in options
+        if 'disabled' not in option.attrib
+        and not (option.getparent().tag == 'optgroup' and 'disabled' in option.getparent().attrib)
+    }
+    selected = [option for option in options if 'selected' in option.attrib]
+    if not select.multiple:
+        # Only the last selected option counts. A drop-down, unlike a list box with `size` above 1, defaults to the
+        # first enabled option.
+        size = re.match(r'[ \t\n\f\r]*\+?(\d+)', select.get('size', ''), re.ASCII)
+        default = [] if size and int(size.group(1)) > 1 else [option for option in options if option in enabled][:1]
+        selected = selected[-1:] or default
+    return [_option_value(option) for option in selected if option in enabled]
+
+
+def _option_value(option: HtmlElement) -> str:
+    """Get the value of an `<option>`: its `value` attribute, else its text with collapsed whitespace."""
+    value = option.get('value')
+    return _ASCII_WHITESPACE_PATTERN.sub(' ', option.text_content()).strip(' ') if value is None else value
+
+
+def _apply_fields(entries: list[_Field], fields: Mapping[str, str | Sequence[str] | None]) -> list[_Field]:
+    """Replace the entries named in `fields` with its values, dropping those set to `None`."""
+    result = [entry for entry in entries if entry.name not in fields]
+    for name, value in fields.items():
+        if value is None:
+            continue
+        values = [value] if isinstance(value, str) else value
+        result.extend(_Field(name, item) for item in values)
+    return result
+
+
+def _form_encoding(form: HtmlElement, page_encoding: str) -> str:
+    """Pick the encoding a browser submits the form in: the first known `accept-charset` label, else the page one."""
+    labels = (form.get('accept-charset') or '').replace(',', ' ').split()
+    encoding = next(filter(None, map(resolve_encoding, labels)), page_encoding)
+    # Browsers never submit in UTF-16, as it isn't ASCII-compatible.
+    return 'utf-8' if encoding.startswith('utf-16') else encoding
+
+
+def _referrer_headers(page_url: str, url: str, method: str) -> dict[str, str]:
+    """Get the `Referer` and `Origin` a browser sends under its default `strict-origin-when-cross-origin` policy."""
+    page = URL(page_url)
+    target = URL(url)
+    page_origin = str(page.origin())
+    # Nothing about an HTTPS page is revealed to a plain HTTP URL.
+    downgrade = page.scheme == 'https' and target.scheme != 'https'
+
+    headers = {}
+    if not downgrade:
+        same_origin = page_origin == str(target.origin())
+        referrer = f'{page_origin}{page.raw_path_qs}'
+        headers['Referer'] = referrer if same_origin and len(referrer) <= _MAX_REFERRER_LENGTH else f'{page_origin}/'
+    if method == 'POST':
+        headers['Origin'] = 'null' if downgrade else page_origin
+    return headers
+
+
+def _encode_body(entries: list[_Field], enctype: str, encoding: str) -> tuple[bytes, str]:
+    """Encode the fields as a POST body, returning it with its `Content-Type` header value."""
+    if enctype == 'multipart/form-data':
+        return _encode_multipart(entries, encoding)
+
+    if enctype == 'text/plain':
+        text = ''.join(f'{entry.name}={entry.value}\r\n' for entry in entries)
+        return text.encode(encoding, 'xmlcharrefreplace'), 'text/plain'
+
+    pairs = [(entry.name, entry.value) for entry in entries]
+    body = urlencode(pairs, encoding=encoding, errors='xmlcharrefreplace').encode()
+    return body, 'application/x-www-form-urlencoded'
+
+
+def _encode_multipart(entries: list[_Field], encoding: str) -> tuple[bytes, str]:
+    """Encode fields as `multipart/form-data`, returning the body and the `Content-Type` header value."""
+    parts: list[bytes] = []
+    for entry in entries:
+        disposition = f'form-data; name="{entry.name.translate(_MULTIPART_NAME_ESCAPES)}"'
+        if entry.is_file:
+            head = f'Content-Disposition: {disposition}; filename=""\r\nContent-Type: application/octet-stream\r\n\r\n'
+        else:
+            head = f'Content-Disposition: {disposition}\r\n\r\n'
+        parts.append((head + entry.value).encode(encoding, 'xmlcharrefreplace'))
+
+    # A random boundary would change the payload on every call and break deduplication.
+    boundary = f'----CrawleeFormBoundary{compute_short_hash(b"".join(parts), length=16)}'
+    delimiter = f'--{boundary}\r\n'.encode()
+    body = b''.join(delimiter + part + b'\r\n' for part in parts) + f'--{boundary}--\r\n'.encode()
+    return body, f'multipart/form-data; boundary={boundary}'
diff --git a/src/crawlee/crawlers/_beautifulsoup/_beautifulsoup_crawling_context.py b/src/crawlee/crawlers/_beautifulsoup/_beautifulsoup_crawling_context.py
index 7aa390cf15..624f36882c 100644
--- a/src/crawlee/crawlers/_beautifulsoup/_beautifulsoup_crawling_context.py
+++ b/src/crawlee/crawlers/_beautifulsoup/_beautifulsoup_crawling_context.py
@@ -1,13 +1,38 @@
+from __future__ import annotations
+
+import asyncio
+import codecs
+import re
+from contextlib import suppress
 from dataclasses import dataclass, fields
+from typing import TYPE_CHECKING
 
 from bs4 import BeautifulSoup
-from typing_extensions import Self
+from bs4.dammit import EncodingDetector
+from lxml.etree import ParserError  # ty: ignore[unresolved-import]
+from lxml.html import HTMLParser, document_fromstring
+from soupsieve import SelectorSyntaxError
 
 from crawlee._utils.docs import docs_group
+from crawlee._utils.html import (
+    decode_html_body,
+    forms_to_requests,
+    get_declared_html_encoding,
+    resolve_encoding,
+    strip_html_comments,
+)
 from crawlee.crawlers import ParsedHttpCrawlingContext
 
 from ._utils import html_to_text
 
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from typing_extensions import Self, Unpack
+
+    from crawlee._request import Request
+    from crawlee._utils.html import FormRequestOptions
+
 
 @dataclass(frozen=True)
 @docs_group('Crawling contexts')
@@ -30,3 +55,84 @@ def from_parsed_http_crawling_context(cls, context: ParsedHttpCrawlingContext[Be
     def html_to_text(self) -> str:
         """Convert the parsed HTML content to newline-separated plain text without tags."""
         return html_to_text(self.parsed_content)
+
+    async def extract_form_requests(
+        self,
+        *,
+        selector: str = 'form',
+        fields: Mapping[str, str | Sequence[str] | None] | None = None,
+        click: bool | Mapping[str, str] = True,
+        all_forms: bool = False,
+        **kwargs: Unpack[FormRequestOptions],
+    ) -> list[Request]:
+        """Create requests submitting the forms matching `selector` the way a browser does.
+
+        By default, only one form is submitted: the first one a browser can submit among those sharing the most field
+        names with `fields`.
+
+        Args:
+            selector: CSS selector for the forms. An invalid one matches no form.
+            fields: Values replacing the form fields or adding new ones. A `None` value drops the field and a sequence
+                submits it once per value. With `all_forms`, only the fields a form has are replaced.
+            click: The submit button to click: `True` for the first enabled one, if any, `False` for none, or a
+                mapping of attributes the button must have, disabled or not, which skips forms without such a button.
+            all_forms: Submit each matching form instead of only one.
+            **kwargs: Additional options passed to `Request.from_url`.
+        """
+        body = await self.http_response.read()
+        content_type = self.http_response.headers.get('content-type')
+
+        def build_requests() -> list[Request]:
+            declared_encoding = get_declared_html_encoding(body, content_type)
+            page_encoding = declared_encoding or _guessed_encoding(body)
+            text = decode_html_body(body, page_encoding)
+            # Searching the text is much cheaper than searching a tree.
+            if not re.search('<form', text, re.IGNORECASE):
+                return []
+
+            # Soup forms are matched to the lxml ones by position, which only holds for a soup built by lxml from the
+            # same text. `BeautifulSoupParser` decodes a page declaring no encoding in its own way.
+            selected = None
+            if selector != 'form':
+                reuse_soup = declared_encoding and self.soup.builder.NAME == 'lxml'
+                soup = self.soup if reuse_soup else BeautifulSoup(text, 'lxml')
+                # Soupsieve raises `NotImplementedError` for pseudo-elements and `ValueError` for escapes past Unicode.
+                try:
+                    selected = {i for i, tag in enumerate(soup.find_all('form')) if tag.css.match(selector)}
+                except (SelectorSyntaxError, NotImplementedError, ValueError):
+                    return []
+                if not selected:
+                    return []
+
+            try:
+                root = document_fromstring(text.encode(), parser=HTMLParser(encoding='utf-8', huge_tree=True))
+            except ParserError:  # A page of only comments has no elements.
+                return []
+            # Newer libxml2 puts forms after `</html>` into a second root, which isn't searched, so the soup forms there
+            # match no position.
+            forms = [form for i, form in enumerate(root.iter('form')) if selected is None or i in selected]
+
+            return forms_to_requests(
+                forms,
+                self.request.loaded_url or self.request.url,
+                page_encoding,
+                fields=fields,
+                click=click,
+                all_forms=all_forms,
+                **kwargs,
+            )
+
+        return await asyncio.to_thread(build_requests)
+
+
+def _guessed_encoding(body: bytes) -> str:
+    """Get the Python codec for the encoding `BeautifulSoup` picks for a page declaring none in the prescan."""
+    # Browsers switch to a `<meta>` charset found past the prescan, but not to a commented-out one.
+    detector = EncodingDetector(strip_html_comments(body), is_html=True)
+    for name in detector.encodings:
+        # Browsers ignore a declared label they don't know, like `base64`.
+        if name == detector.declared_encoding and not resolve_encoding(name):
+            continue
+        with suppress(LookupError):
+            return resolve_encoding(name) or codecs.lookup(name).name
+    return 'utf-8'
diff --git a/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py b/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py
index c29b9499d0..d3cec71095 100644
--- a/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py
+++ b/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py
@@ -1,13 +1,27 @@
+from __future__ import annotations
+
+import asyncio
 from dataclasses import dataclass, fields
+from typing import TYPE_CHECKING
 
+from cssselect import SelectorError
+from lxml.html import FormElement
 from parsel import Selector
-from typing_extensions import Self
 
 from crawlee._utils.docs import docs_group
+from crawlee._utils.html import forms_to_requests, get_declared_html_encoding
 from crawlee.crawlers._abstract_http import ParsedHttpCrawlingContext
 
 from ._utils import html_to_text
 
+if TYPE_CHECKING:
+    from collections.abc import Mapping, Sequence
+
+    from typing_extensions import Self, Unpack
+
+    from crawlee._request import Request
+    from crawlee._utils.html import FormRequestOptions
+
 
 @dataclass(frozen=True)
 @docs_group('Crawling contexts')
@@ -30,3 +44,53 @@ def from_parsed_http_crawling_context(cls, context: ParsedHttpCrawlingContext[Se
     def html_to_text(self) -> str:
         """Convert the parsed HTML content to newline-separated plain text without tags."""
         return html_to_text(self.parsed_content)
+
+    async def extract_form_requests(
+        self,
+        *,
+        selector: str = 'form',
+        fields: Mapping[str, str | Sequence[str] | None] | None = None,
+        click: bool | Mapping[str, str] = True,
+        all_forms: bool = False,
+        **kwargs: Unpack[FormRequestOptions],
+    ) -> list[Request]:
+        """Create requests submitting the forms matching `selector` the way a browser does.
+
+        By default, only one form is submitted: the first one a browser can submit among those sharing the most field
+        names with `fields`.
+
+        Args:
+            selector: CSS selector for the forms. An invalid one matches no form.
+            fields: Values replacing the form fields or adding new ones. A `None` value drops the field and a sequence
+                submits it once per value. With `all_forms`, only the fields a form has are replaced.
+            click: The submit button to click: `True` for the first enabled one, if any, `False` for none, or a
+                mapping of attributes the button must have, disabled or not, which skips forms without such a button.
+            all_forms: Submit each matching form instead of only one.
+            **kwargs: Additional options passed to `Request.from_url`.
+        """
+        body = await self.http_response.read()
+        content_type = self.http_response.headers.get('content-type')
+
+        def build_requests() -> list[Request]:
+            try:
+                matches = self.selector.css(selector)
+            except (SelectorError, ValueError):  # Parsel raises the latter for invalid XPath, like an unknown prefix.
+                return []
+            # The selector can also match other elements, text or attributes.
+            forms = [match.root for match in matches if isinstance(match.root, FormElement)]
+
+            # `ParselParser` reads a page declaring no encoding as UTF-8.
+            page_encoding = get_declared_html_encoding(body, content_type) or 'utf-8'
+
+            return forms_to_requests(
+                forms,
+                self.request.loaded_url or self.request.url,
+                page_encoding,
+                fields=fields,
+                click=click,
+                all_forms=all_forms,
+                **kwargs,
+            )
+
+        # A large page would block the event loop.
+        return await asyncio.to_thread(build_requests)
diff --git a/tests/unit/_utils/test_html.py b/tests/unit/_utils/test_html.py
index bb7ad3d480..76a7fdfe2c 100644
--- a/tests/unit/_utils/test_html.py
+++ b/tests/unit/_utils/test_html.py
@@ -1,13 +1,94 @@
 from __future__ import annotations
 
 import codecs
+from typing import TYPE_CHECKING, Any
+from unittest.mock import AsyncMock, Mock, patch
+from urllib.parse import parse_qs, urlencode, urlsplit
 
 import pytest
 
-from crawlee._utils.html import _ENCODING_BY_LABEL, _PRESCAN_BYTES, decode_html_body, get_declared_html_encoding
+from crawlee import HttpHeaders, Request
+from crawlee._request import RequestOptions
+from crawlee._utils.html import (
+    _ENCODING_BY_LABEL,
+    _PRESCAN_BYTES,
+    FormRequestOptions,
+    decode_html_body,
+    get_declared_html_encoding,
+)
+from crawlee.crawlers import BeautifulSoupCrawlingContext, ParselCrawlingContext
+from crawlee.crawlers._beautifulsoup._beautifulsoup_parser import BeautifulSoupParser
+from crawlee.crawlers._parsel._parsel_parser import ParselParser
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    from crawlee.crawlers import BeautifulSoupParserType
+
+    ExtractFormRequests = Callable[..., Awaitable[list[Request]]]
 
 _CZECH = 'Test dekódování znaků českého jazyka'
+_JAPANESE = '東京で文字コードのテストを行います。'
 _FRENCH = 'Test de décodage des caractères de la langue française dans une œuvre'
+_PAGE_URL = 'https://example.com/page/index.html'
+_REFERRER_PAGE_URL = 'https://user:pass@example.com/page?token=1#top'
+
+
+def mock_context(html: str, page_request: Request | None, content_type: str | None, encoding: str | None) -> Mock:
+    body = html.encode(encoding or 'utf-8', 'xmlcharrefreplace')
+    return Mock(
+        request=page_request or Request.from_url(_PAGE_URL),
+        http_response=Mock(
+            headers=HttpHeaders({'Content-Type': content_type} if content_type else {}),
+            read=AsyncMock(return_value=body),
+        ),
+    )
+
+
+async def extract_with_parsel(
+    html: str,
+    page_request: Request | None = None,
+    content_type: str | None = None,
+    encoding: str | None = None,
+    **kwargs: Any,
+) -> list[Request]:
+    context = mock_context(html, page_request, content_type, encoding)
+    context.selector = await ParselParser().parse(context.http_response)
+    return await ParselCrawlingContext.extract_form_requests(context, **kwargs)
+
+
+async def extract_with_beautifulsoup(
+    html: str,
+    page_request: Request | None = None,
+    content_type: str | None = None,
+    encoding: str | None = None,
+    parser: BeautifulSoupParserType = 'lxml',
+    **kwargs: Any,
+) -> list[Request]:
+    context = mock_context(html, page_request, content_type, encoding)
+    context.soup = await BeautifulSoupParser(parser).parse(context.http_response)
+    return await BeautifulSoupCrawlingContext.extract_form_requests(context, **kwargs)
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(extract_with_parsel, id='parsel'),
+        pytest.param(extract_with_beautifulsoup, id='beautifulsoup'),
+    ]
+)
+def extract_form_requests(request: pytest.FixtureRequest) -> ExtractFormRequests:
+    return request.param
+
+
+def request_paths(requests: list[Request]) -> list[str]:
+    return [urlsplit(request.url).path for request in requests]
+
+
+def submitted_fields(request: Request) -> dict[str, str | list[str]]:
+    """Get the fields a request submits, in the shape of the `fields` argument."""
+    query = urlsplit(request.url).query if request.method == 'GET' else (request.payload or b'').decode()
+    parsed = parse_qs(query, keep_blank_values=True)
+    return {name: values[0] if len(values) == 1 else values for name, values in parsed.items()}
 
 
 @pytest.mark.parametrize(
@@ -134,3 +215,755 @@ def test_encoding_labels_resolve_to_python_codecs() -> None:
     """Every encoding in the label table is a Python codec."""
     for codec in set(_ENCODING_BY_LABEL.values()):
         codecs.lookup(codec)
+
+
+def test_form_request_options() -> None:
+    """`FormRequestOptions` has every request option except those the form or enqueuing sets."""
+    options = RequestOptions.__required_keys__ | RequestOptions.__optional_keys__
+    expected = options - {'url', 'method', 'payload', 'unique_key', 'id', 'enqueue_strategy'}
+
+    assert FormRequestOptions.__required_keys__ | FormRequestOptions.__optional_keys__ == expected
+
+
+async def test_get_form(extract_form_requests: ExtractFormRequests) -> None:
+    """A GET form replaces the query of its action with the fields and keeps the fragment."""
+    html = '<form action="?old=1#top"><input name="q" value="shoes"><input name="page" value="2"></form>'
+
+    [request] = await extract_form_requests(html)
+
+    assert request.method == 'GET'
+    assert request.payload is None
+    assert request.url == 'https://example.com/page/index.html?q=shoes&page=2#top'
+
+
+async def test_post_form(extract_form_requests: ExtractFormRequests) -> None:
+    """A POST form sends the fields as an urlencoded body, which counts towards the unique key."""
+    html = '<form method="post" action="login"><input name="user" value="a b"><input name="pass" value="&"></form>'
+
+    [request] = await extract_form_requests(html)
+    [other] = await extract_form_requests(html, fields={'user': 'c'})
+
+    assert request.method == 'POST'
+    assert request.url == 'https://example.com/page/login'
+    assert request.headers['content-type'] == 'application/x-www-form-urlencoded'
+    assert request.payload == b'user=a+b&pass=%26'
+    assert request.unique_key != other.unique_key
+
+
+async def test_multipart_form(extract_form_requests: ExtractFormRequests) -> None:
+    """A multipart form is encoded with a deterministic boundary and empty file parts."""
+    html = (
+        '<form method="post" enctype="multipart/form-data">'
+        '<input name="title" value="hi"><input type="file" name="doc">'
+        '</form>'
+    )
+
+    [request] = await extract_form_requests(html)
+    [again] = await extract_form_requests(html)
+
+    content_type = request.headers['content-type']
+    assert content_type.startswith('multipart/form-data; boundary=')
+    boundary = content_type.split('boundary=')[1]
+    assert (
+        request.payload
+        == (
+            f'--{boundary}\r\n'
+            'Content-Disposition: form-data; name="title"\r\n\r\nhi\r\n'
+            f'--{boundary}\r\n'
+            'Content-Disposition: form-data; name="doc"; filename=""\r\n'
+            'Content-Type: application/octet-stream\r\n\r\n\r\n'
+            f'--{boundary}--\r\n'
+        ).encode()
+    )
+    assert request.unique_key == again.unique_key
+
+
+async def test_multipart_escapes(extract_form_requests: ExtractFormRequests) -> None:
+    """Multipart names escape quotes and line breaks, and values submit line breaks as CRLF."""
+    html = '<form method="post" enctype="multipart/form-data"><textarea name="a&quot;b">x\ny</textarea></form>'
+
+    [request] = await extract_form_requests(html, fields={'c\nd': 'v'})
+
+    assert b'name="a%22b"\r\n\r\nx\r\ny\r\n' in (request.payload or b'')
+    assert b'name="c%0D%0Ad"\r\n\r\nv\r\n' in (request.payload or b'')
+
+
+async def test_text_plain_form(extract_form_requests: ExtractFormRequests) -> None:
+    """A `text/plain` form sends one field per line."""
+    html = '<form method="post" enctype="TEXT/PLAIN"><input name="a" value="1"><input name="b" value="2"></form>'
+
+    [request] = await extract_form_requests(html)
+
+    assert request.headers['content-type'] == 'text/plain'
+    assert request.payload == b'a=1\r\nb=2\r\n'
+
+
+async def test_submitted_fields(extract_form_requests: ExtractFormRequests) -> None:
+    """Only the fields a browser would submit are collected."""
+    html = """
+    <form>
+        <input name="text" value="t">
+        <input type="checkbox" name="checked" value="c1" checked>
+        <input type="checkbox" name="unchecked" value="c2">
+        <input type="checkbox" name="no-value" checked>
+        <input type="checkbox" name="empty-value" value="" checked>
+        <input type="radio" name="radio" value="r1" checked>
+        <input type="radio" name="radio" value="r2" checked>
+        <input type="radio" name="radio" value="r3">
+        <select name="first"><option value="o1">1</option><option value="o2">2</option></select>
+        <select name="last"><option value="a" selected>A</option><option value="b" selected>B</option></select>
+        <select name="first-enabled"><option value="off" disabled>Off</option><option value="on">On</option></select>
+        <select name="list-box" size="2"><option value="l1">1</option><option value="l2">2</option></select>
+        <select name="placeholder"><option value="" disabled selected>Pick</option><option value="p">P</option></select>
+        <select name="multi-disabled" multiple>
+            <option value="d1" disabled selected>1</option>
+            <optgroup disabled><option value="d2" selected>2</option></optgroup>
+            <option value="e" selected>3</option>
+        </select>
+        <select name="text-value"><option> spaced\n  text </option></select>
+        <select name="no-options"></select>
+        <select name="multi" multiple>
+            <option value="m1" selected>1</option><option value="m2">2</option><option value="m3" selected>3</option>
+        </select>
+        <textarea name="area">\n\nlong text</textarea>
+        <input name="disabled" value="d" disabled>
+        <fieldset disabled><input name="in-fieldset" value="f"></fieldset>
+        <input type="reset" name="reset" value="r">
+        <input type="button" name="button" value="b">
+        <input type="file" name="file">
+        <input name="empty">
+        <input type="hidden" name="hidden">
+        <input value="no name">
+    </form>
+    """
+
+    [request] = await extract_form_requests(html)
+
+    assert submitted_fields(request) == {
+        'text': 't',
+        'checked': 'c1',
+        'no-value': 'on',
+        'empty-value': '',
+        'radio': 'r2',
+        'first': 'o1',
+        'last': 'b',
+        'first-enabled': 'on',
+        'multi-disabled': 'e',
+        'text-value': 'spaced text',
+        'multi': ['m1', 'm3'],
+        'area': '\r\nlong text',
+        'file': '',
+        'empty': '',
+        'hidden': '',
+    }
+
+
+async def test_form_attribute(extract_form_requests: ExtractFormRequests) -> None:
+    """Fields are assigned to forms by their `form` attribute, and `fields` fill in only the fields a form has."""
+    html = """
+    <form id="search" action="/search"><input name="q" value="x"><input name="other" value="o" form="login">
+        <input name="orphan" value="z" form="missing"></form>
+    <select name="lang" form="search"><option value="en" selected>EN</option></select>
+    <button form="search" name="go">Go</button>
+    <form id="login" action="/login"></form>
+    <form action="/empty"></form>
+    """
+
+    search, login, empty = await extract_form_requests(html, fields={'q': 'y', 'other': 'p'}, all_forms=True)
+
+    assert submitted_fields(search) == {'q': 'y', 'lang': 'en', 'go': ''}
+    assert submitted_fields(login) == {'other': 'p'}
+    assert submitted_fields(empty) == {}
+
+
+async def test_option_text_keeps_nbsp(extract_form_requests: ExtractFormRequests) -> None:
+    """An `<option>` without a value collapses only ASCII whitespace in its text."""
+    html = '<form><select name="s"><option>&nbsp;a&nbsp;\n b </option></select></form>'
+
+    [request] = await extract_form_requests(html, content_type='text/html; charset=utf-8')
+
+    assert submitted_fields(request) == {'s': '\xa0a\xa0 b'}
+
+
+async def test_input_value_sanitization(extract_form_requests: ExtractFormRequests) -> None:
+    """Input values are sanitized per type, like line breaks dropped from text and an invalid color reset to black."""
+    html = """
+    <form>
+        <input name="text" value="a\nb">
+        <input type="email" name="email" value=" x@y.z ">
+        <input type="hidden" name="hidden" value="c\nd">
+        <input type="color" name="color" value="#AABBCC">
+        <input type="color" name="no-color">
+        <input type="number" name="number" value="-1.5e3">
+        <input type="number" name="bad-number" value="abc">
+        <input type="number" name="number-line-break" value="1&#10;">
+        <input type="number" name="non-ascii-number" value="\u0661">
+    </form>
+    """
+
+    [request] = await extract_form_requests(html)
+
+    assert submitted_fields(request) == {
+        'text': 'ab',
+        'email': 'x@y.z',
+        'hidden': 'c\r\nd',
+        'color': '#aabbcc',
+        'no-color': '#000000',
+        'number': '-1.5e3',
+        'bad-number': '',
+        'number-line-break': '',
+        'non-ascii-number': '',
+    }
+
+
+async def test_disabled_fieldset(extract_form_requests: ExtractFormRequests) -> None:
+    """A disabled `<fieldset>` disables all fields inside it except its first `<legend>`, and an enabled one none."""
+    html = """
+    <form>
+        <fieldset disabled><legend><input name="first-legend"></legend><legend><input name="second-legend"></legend>
+        </fieldset>
+        <fieldset disabled><fieldset disabled></fieldset><label><input name="a"></label><input name="b"></fieldset>
+        <fieldset><label><input name="c"></label></fieldset>
+    </form>
+    """
+
+    [request] = await extract_form_requests(html)
+
+    assert submitted_fields(request) == {'first-legend': '', 'c': ''}
+
+
+async def test_template_contents_ignored(extract_form_requests: ExtractFormRequests) -> None:
+    """Fields and forms inside a `<template>` are neither submitted nor picked."""
+    html = """
+    <template><form action="/template"><input name="q"></form></template>
+    <form action="/page"><input name="a" value="1"><template><input name="b" value="2"></template></form>
+    """
+
+    [request] = await extract_form_requests(html, fields={'q': 'x'})
+
+    assert request.url.startswith('https://example.com/page?')
+    assert submitted_fields(request) == {'a': '1', 'q': 'x'}
+
+
+async def test_fields_argument(extract_form_requests: ExtractFormRequests) -> None:
+    """Values from `fields` replace, drop and add fields."""
+    html = '<form><input name="keep" value="k"><input name="replace" value="old"><input name="drop" value="d"></form>'
+
+    [request] = await extract_form_requests(html, fields={'replace': 'new', 'drop': None, 'tags': ['a', 'b']})
+
+    assert submitted_fields(request) == {'keep': 'k', 'replace': 'new', 'tags': ['a', 'b']}
+
+
+@pytest.mark.parametrize(
+    ('html', 'expected_query'),
+    [
+        pytest.param('<form method="put"><input name="q" value="x"></form>', 'q=x', id='unknown-method-is-get'),
+        pytest.param(
+            '<form accept-charset="utf-16"><input name="q" value="é"></form>', 'q=%C3%A9', id='utf-16-submits-utf-8'
+        ),
+        pytest.param(
+            '<form id="f"></form><form id="f"></form><input name="q" value="x" form="f">',
+            'q=x',
+            id='first-duplicate-id-wins',
+        ),
+        pytest.param(
+            '<div id="f"></div><form id="f"><input name="q" value="x"></form><input name="z" value="1" form="f">',
+            'q=x',
+            id='first-id-not-a-form',
+        ),
+        pytest.param(
+            '<template><div id="f"></div></template><form id="f"><input name="q" value="x"></form>'
+            '<input name="z" value="1" form="f">',
+            'q=x&z=1',
+            id='id-in-template-ignored',
+        ),
+        pytest.param('<FORM><INPUT TYPE="IMAGE" NAME="q"></FORM>', 'q.x=0&q.y=0', id='uppercase-tags'),
+        pytest.param(
+            '<form id=""><input name="q" value="x"></form><input name="z" value="1" form="">',
+            'q=x',
+            id='empty-form-attribute',
+        ),
+        pytest.param('<form><input name="q" value="x"><button>Go</button></form>', 'q=x', id='unnamed-button'),
+        pytest.param('<form><input type="image" name="map" src="go.png"></form>', 'map.x=0&map.y=0', id='image-button'),
+        pytest.param('<form><input type="image" src="go.png"></form>', 'x=0&y=0', id='unnamed-image-button'),
+        pytest.param('<form><button type="foo" name="b" value="1"></button></form>', 'b=1', id='unknown-button-type'),
+        pytest.param('<form><button type="image" name="b" value="1"></button></form>', 'b=1', id='image-type-button'),
+        pytest.param(
+            '<form><select name="s" size="٢"><option value="a">A</option></select></form>',
+            's=a',
+            id='non-ascii-select-size',
+        ),
+    ],
+)
+async def test_browser_rules(extract_form_requests: ExtractFormRequests, html: str, expected_query: str) -> None:
+    """Less obvious browser rules are followed."""
+    [request] = await extract_form_requests(html)
+
+    assert request.method == 'GET'
+    assert urlsplit(request.url).query == expected_query
+
+
+@pytest.mark.parametrize(
+    ('html', 'expected_url'),
+    [
+        pytest.param('<form></form>', 'https://example.com/page/index.html', id='no-action'),
+        pytest.param('<form action="../up"></form>', 'https://example.com/up', id='relative'),
+        pytest.param('<form action=" /go "></form>', 'https://example.com/go', id='whitespace-around-action'),
+        pytest.param('<form action="&nbsp;/go"></form>', 'https://example.com/page/%C2%A0/go', id='nbsp-in-action'),
+        pytest.param(
+            '<head><base href=" https://other.com/dir/ "></head><form action=" "></form>',
+            'https://other.com/dir/',
+            id='whitespace-around-base-href',
+        ),
+        pytest.param(
+            '<head><base href="https://other.com/dir/"></head><form action=" "></form>',
+            'https://other.com/dir/',
+            id='whitespace-action-base-href',
+        ),
+        pytest.param(
+            '<head><base href="https://other.com/dir/"></head><form action="go"></form>',
+            'https://other.com/dir/go',
+            id='base-href',
+        ),
+        pytest.param(
+            '<head><base href="https://other.com/dir/"></head><form></form>',
+            'https://example.com/page/index.html',
+            id='base-href-no-action',
+        ),
+        pytest.param(
+            '<head><base href="http://[bad"></head><form action="go"></form>',
+            'https://example.com/page/go',
+            id='invalid-base-href',
+        ),
+        pytest.param(
+            '<head><base target="_blank"></head><form action="go"></form>',
+            'https://example.com/page/go',
+            id='base-without-href',
+        ),
+        pytest.param(
+            '<head><template><base href="https://other.com/dir/"></template></head><form action="go"></form>',
+            'https://example.com/page/go',
+            id='base-href-in-template-ignored',
+        ),
+    ],
+)
+async def test_action_resolution(extract_form_requests: ExtractFormRequests, html: str, expected_url: str) -> None:
+    """The action is resolved against `<base href>`, and a missing action submits to the page URL."""
+    [request] = await extract_form_requests(html)
+
+    assert request.url == expected_url
+
+
+async def test_action_uses_loaded_url(extract_form_requests: ExtractFormRequests) -> None:
+    """The action is resolved against the URL the page was loaded from after redirects."""
+    page_request = Request.from_url(_PAGE_URL, loaded_url='https://example.com/moved/index.html')
+
+    [request] = await extract_form_requests('<form action="go"></form>', page_request=page_request)
+
+    assert request.url == 'https://example.com/moved/go'
+
+
+async def test_unsubmittable_forms_skipped(extract_form_requests: ExtractFormRequests) -> None:
+    """Dialog forms and forms whose action isn't a valid HTTP(S) URL are skipped."""
+    html = (
+        '<form action="javascript:void(0)"></form><form action="mailto:a@b.c"></form>'
+        '<form action="http://[bad"></form><form action="https://exa mple.com/"></form>'
+        '<form action="http:x"></form><form method="dialog"><button>Close</button></form><form action="/ok"></form>'
+    )
+
+    assert request_paths(await extract_form_requests(html, all_forms=True)) == ['/ok']
+
+
+async def test_request_options(extract_form_requests: ExtractFormRequests) -> None:
+    """Request options are applied, and `headers` are merged over the ones the form sets."""
+    html = '<form method="post" action="/login"><input name="q" value="x"></form>'
+    headers = {'X-Custom': '1', 'referer': 'https://example.com/'}
+
+    [request] = await extract_form_requests(html, headers=headers, label='detail', use_extended_unique_key=False)
+    [get_request] = await extract_form_requests(html.replace('post', 'get'), headers=headers)
+
+    assert request.label == 'detail'
+    assert request.unique_key == 'https://example.com/login'
+    assert request.headers['x-custom'] == '1'
+    assert request.headers['content-type'] == 'application/x-www-form-urlencoded'
+    assert request.headers['referer'] == 'https://example.com/'
+    assert get_request.headers['referer'] == 'https://example.com/'
+
+
+@pytest.mark.parametrize(
+    ('page_url', 'html', 'expected_referer', 'expected_origin'),
+    [
+        pytest.param(
+            _REFERRER_PAGE_URL,
+            '<form method="post" action="/login">',
+            'https://example.com/page?token=1',
+            'https://example.com',
+            id='same-origin',
+        ),
+        pytest.param(
+            _REFERRER_PAGE_URL,
+            '<form method="post" action="https://other.com/">',
+            'https://example.com/',
+            'https://example.com',
+            id='other-host',
+        ),
+        pytest.param(
+            _REFERRER_PAGE_URL,
+            '<form method="post" action="https://example.com:8443/">',
+            'https://example.com/',
+            'https://example.com',
+            id='other-port',
+        ),
+        pytest.param(
+            'https://example.com:443/page',
+            '<form method="post" action="/login">',
+            'https://example.com/page',
+            'https://example.com',
+            id='default-port',
+        ),
+        pytest.param(
+            'https://example.com',
+            '<form method="post" action="/login">',
+            'https://example.com/',
+            'https://example.com',
+            id='empty-path',
+        ),
+        pytest.param(
+            _REFERRER_PAGE_URL,
+            '<base href="https://other.com/"><form method="post" action="/login">',
+            'https://example.com/',
+            'https://example.com',
+            id='base-href-ignored',
+        ),
+        pytest.param(
+            _REFERRER_PAGE_URL, '<form method="post" action="http://example.com/">', None, 'null', id='https-to-http'
+        ),
+        pytest.param(
+            'http://example.com/page',
+            '<form method="post" action="https://example.com/">',
+            'http://example.com/',
+            'http://example.com',
+            id='http-to-https',
+        ),
+        pytest.param(
+            _REFERRER_PAGE_URL,
+            '<form action="/search">',
+            'https://example.com/page?token=1',
+            None,
+            id='get-without-origin',
+        ),
+        pytest.param(
+            f'https://example.com/page?q={"a" * 4096}',
+            '<form action="/search">',
+            'https://example.com/',
+            None,
+            id='long-referrer-cut',
+        ),
+    ],
+)
+async def test_referrer_headers(
+    extract_form_requests: ExtractFormRequests,
+    page_url: str,
+    html: str,
+    expected_referer: str | None,
+    expected_origin: str | None,
+) -> None:
+    """The `Referer` and `Origin` headers come from the page URL under the default referrer policy of browsers."""
+    [request] = await extract_form_requests(f'{html}</form>', page_request=Request.from_url(page_url))
+
+    assert request.headers.get('referer') == expected_referer
+    assert request.headers.get('origin') == expected_origin
+
+
+async def test_click_first_button(extract_form_requests: ExtractFormRequests) -> None:
+    """The first enabled submit button is submitted in document order by default, and none with `click=False`."""
+    html = """
+    <form>
+        <button type="button" name="plain" value="p">Plain</button>
+        <input type="submit" name="off" value="o" disabled>
+        <fieldset disabled><input type="submit" name="off" value="f"></fieldset>
+        <button type="submit" name="go" value="first">Go</button>
+        <input type="image" name="map" src="go.png">
+        <input name="q" value="x">
+    </form>
+    """
+
+    [request] = await extract_form_requests(html)
+    [unclicked] = await extract_form_requests(html, click=False)
+
+    assert urlsplit(request.url).query == 'go=first&q=x'
+    assert urlsplit(unclicked.url).query == 'q=x'
+
+
+async def test_click_button_overrides(extract_form_requests: ExtractFormRequests) -> None:
+    """`click` picks the button by its attributes and the button overrides apply."""
+    html = """
+    <form action="/save" method="get">
+        <input name="q" value="x">
+        <input type="submit" name="action" value="save">
+        <button name="action" value="delete" formaction="/delete" formmethod="post">Delete</button>
+    </form>
+    """
+
+    [request] = await extract_form_requests(html, click={'value': 'delete'})
+
+    assert request.method == 'POST'
+    assert request.url == 'https://example.com/delete'
+    assert submitted_fields(request) == {'q': 'x', 'action': 'delete'}
+
+
+async def test_empty_button_overrides(extract_form_requests: ExtractFormRequests) -> None:
+    """Empty `formaction`, `formmethod` and `formenctype` override the form attributes with their defaults."""
+    html = """
+    <form action="/save" method="post" enctype="text/plain">
+        <input name="q" value="x">
+        <button formaction="" formmethod="" formenctype="">Go</button>
+    </form>
+    """
+
+    [request] = await extract_form_requests(html)
+
+    assert request.method == 'GET'
+    assert request.url == f'{_PAGE_URL}?q=x'
+
+
+async def test_click_disabled_button(extract_form_requests: ExtractFormRequests) -> None:
+    """`click` picks a disabled button only if no enabled one matches."""
+    html = (
+        '<form><button name="go" value="back" disabled>Back</button><button name="go" value="next">Next</button></form>'
+    )
+
+    [enabled] = await extract_form_requests(html, click={'name': 'go'})
+    [disabled] = await extract_form_requests(html, click={'value': 'back'})
+
+    assert submitted_fields(enabled) == {'go': 'next'}
+    assert submitted_fields(disabled) == {'go': 'back'}
+
+
+@pytest.mark.parametrize(
+    ('click', 'expected_paths'),
+    [
+        pytest.param({'name': 'log-in'}, ['/login'], id='by-name'),
+        pytest.param({'id': 'find-button'}, ['/search'], id='by-id'),
+        pytest.param({'name': 'missing'}, [], id='no-match'),
+        pytest.param({}, ['/search'], id='any-button'),
+    ],
+)
+async def test_click_picks_form(
+    extract_form_requests: ExtractFormRequests, click: dict[str, str], expected_paths: list[str]
+) -> None:
+    """A `click` mapping submits the form with a matching button."""
+    html = """
+    <form action="/plain"><input name="q" value="y"></form>
+    <form action="/search"><input name="q" value="x"><input type="submit" id="find-button" name="find"></form>
+    <form action="/login"><input name="user" value="me"><button name="log-in">Log in</button></form>
+    """
+
+    assert request_paths(await extract_form_requests(html, click=click)) == expected_paths
+
+
+async def test_selector(extract_form_requests: ExtractFormRequests) -> None:
+    """`selector` narrows the forms, skipping other elements it matches."""
+    html = '<form id="a" action="/a"></form><div id="b"></div><form id="c" action="/c"></form>'
+
+    assert request_paths(await extract_form_requests(html, selector='#c, #b')) == ['/c']
+
+
+@pytest.mark.parametrize(
+    'selector',
+    [
+        pytest.param('#missing', id='no-match'),
+        pytest.param('form::text, form::attr(action)', id='text-and-attributes'),
+        pytest.param('form[', id='syntax-error'),
+        pytest.param('form:unknown', id='unknown-pseudo-class'),
+        pytest.param('ns|form', id='unknown-namespace'),
+        pytest.param('#\\110000', id='escape-past-unicode'),
+    ],
+)
+async def test_selector_without_forms(extract_form_requests: ExtractFormRequests, selector: str) -> None:
+    """A selector that is invalid or matches no form yields no requests."""
+    assert await extract_form_requests('<form action="/a">text</form>', selector=selector) == []
+
+
+@pytest.mark.parametrize(
+    ('html', 'fields', 'expected_paths'),
+    [
+        pytest.param(
+            '<form action="/subscribe"><input name="email"><input name="name"><input name="city"></form>'
+            '<form action="/login"><input name="email"><input name="password"></form>',
+            {'email': 'me@example.com', 'password': 'secret'},
+            ['/login'],
+            id='most-shared-names',
+        ),
+        pytest.param(
+            '<form action="/header"><input name="q"></form><form action="/footer"><input name="q"></form>',
+            {'q': 'shoes'},
+            ['/header'],
+            id='tie-keeps-document-order',
+        ),
+        pytest.param(
+            '<form action="/a"><input name="q"></form><form action="/b"><input name="user"></form>',
+            {'token': 'x'},
+            ['/a'],
+            id='no-shared-name-first-form',
+        ),
+        pytest.param(
+            '<form method="dialog"></form><form action="javascript:void(0)"></form><form action="/ok"></form>',
+            {},
+            ['/ok'],
+            id='unsubmittable-forms-passed-over',
+        ),
+        pytest.param(
+            '<form action="/search"><input name="q"></form>'
+            '<form action="javascript:login()"><input name="username"><input name="password"></form>',
+            {'username': 'me', 'password': 'secret'},
+            [],
+            id='best-form-unsubmittable',
+        ),
+    ],
+)
+async def test_form_choice(
+    extract_form_requests: ExtractFormRequests, html: str, fields: dict[str, str], expected_paths: list[str]
+) -> None:
+    """The first submittable form among those sharing the most field names with `fields` is submitted."""
+    assert request_paths(await extract_form_requests(html, fields=fields)) == expected_paths
+
+
+@pytest.mark.parametrize(
+    'html',
+    [
+        pytest.param('<p>No forms here.</p>', id='no-form'),
+        pytest.param('<!-- <form action="/x"><input name="q"></form> -->', id='commented-out-form'),
+    ],
+)
+async def test_page_without_forms(extract_form_requests: ExtractFormRequests, html: str) -> None:
+    """A page without forms yields no requests."""
+    assert await extract_form_requests(html) == []
+
+
+async def test_xml_declaration_page(extract_form_requests: ExtractFormRequests) -> None:
+    """An HTML page starting with an XML declaration is read as HTML."""
+    html = '<?xml version="1.0" encoding="UTF-8"?><html><body><form action="/ok"></form></body></html>'
+
+    assert request_paths(await extract_form_requests(html, content_type='text/html')) == ['/ok']
+
+
+async def test_form_after_html_end(extract_form_requests: ExtractFormRequests) -> None:
+    """A form after `</html>` doesn't shift the forms before it."""
+    html = '<html><body><form id="ok" action="/ok"></form></body></html><form action="/after"></form>'
+
+    # Newer libxml2 puts content after `</html>` into a second root, which isn't searched, older versions keep it.
+    assert request_paths(await extract_form_requests(html, all_forms=True)) in (['/ok'], ['/ok', '/after'])
+    assert request_paths(await extract_form_requests(html, selector='#ok')) == ['/ok']
+    assert request_paths(await extract_form_requests(html, selector='[action="/after"]')) in ([], ['/after'])
+
+
+@pytest.mark.parametrize('parser', [pytest.param('lxml', id='lxml'), pytest.param('html5lib', id='html5lib')])
+async def test_beautifulsoup_form_inside_select(parser: BeautifulSoupParserType) -> None:
+    """Soup forms are matched to the right ones when the parser moves a form out of a `<select>`."""
+    html = '<select><form action="/x"></form></select><form id="y" action="/y"></form>'
+
+    # With a declared encoding, a soup built by lxml is reused.
+    content_type = 'text/html; charset=utf-8'
+    requests = await extract_with_beautifulsoup(html, content_type=content_type, parser=parser, selector='#y')
+
+    assert request_paths(requests) == ['/y']
+
+
+async def test_deeply_nested_form(extract_form_requests: ExtractFormRequests) -> None:
+    """Fields of a form nested deeper than the default libxml2 limit are collected."""
+    html = '<div>' * 300 + '<form><input name="q" value="x"></form>' + '</div>' * 300
+
+    [request] = await extract_form_requests(html)
+
+    assert submitted_fields(request) == {'q': 'x'}
+
+
+@pytest.mark.parametrize(
+    ('attributes', 'content_type'),
+    [
+        pytest.param('accept-charset="bogus,windows-1250"', None, id='accept-charset'),
+        pytest.param('', 'text/html; charset=windows-1250', id='header'),
+    ],
+)
+@pytest.mark.parametrize('method', [pytest.param('get', id='get'), pytest.param('post', id='post')])
+async def test_submission_encoding(
+    extract_form_requests: ExtractFormRequests, attributes: str, content_type: str | None, method: str
+) -> None:
+    """Values are encoded in the form or page charset, with unsupported characters as character references."""
+    html = f'<form method="{method}" {attributes}><input name="q"></form>'
+
+    [request] = await extract_form_requests(html, content_type=content_type, fields={'q': 'Příliš ✓'})
+
+    encoded = urlsplit(request.url).query if method == 'get' else (request.payload or b'').decode()
+    assert encoded == 'q=P%F8%EDli%9A+%26%2310003%3B'
+
+
+@pytest.mark.parametrize(
+    ('html', 'value', 'encoding'),
+    [
+        pytest.param(f'<p>{_CZECH * 5}</p>', _CZECH, 'cp1250', id='guess'),
+        # `BeautifulSoup` names this encoding `CP932`, which isn't a WHATWG label.
+        pytest.param(f'<p>{_JAPANESE * 5}</p>', _JAPANESE, 'shift_jis', id='guess-outside-whatwg-labels'),
+        pytest.param(f'<meta charset="base64"><p>{_CZECH * 5}</p>', _CZECH, 'cp1250', id='unknown-label'),
+        pytest.param(f'<!-- <meta charset="utf-8"> --><p>{_CZECH * 5}</p>', _CZECH, 'cp1250', id='commented-out-meta'),
+        pytest.param(
+            f'<!-- <meta charset="utf-8"> --><p>{_CZECH * 5}</p>',
+            _CZECH,
+            'utf-8',
+            id='commented-out-meta-same-as-guess',
+        ),
+        # `BeautifulSoup` looks for a `<meta>` in the first 5% of a page, so it takes a large one.
+        pytest.param(
+            f'<style>{"a" * 10_000}</style><meta charset="utf-8">{"<p>text</p>" * 20_000}',
+            _CZECH,
+            'utf-8',
+            id='late-meta',
+        ),
+        pytest.param('', _CZECH, 'cp1252', id='ascii'),
+    ],
+)
+async def test_beautifulsoup_undeclared_encoding(html: str, value: str, encoding: str) -> None:
+    """A page declaring no encoding in the prescan submits in the one browsers would pick."""
+    page = f'{html}<form><input name="q"></form>'
+
+    [request] = await extract_with_beautifulsoup(page, content_type='text/html', encoding=encoding, fields={'q': value})
+
+    assert urlsplit(request.url).query == urlencode({'q': value}, encoding=encoding, errors='xmlcharrefreplace')
+
+
+async def test_beautifulsoup_guess_fallback() -> None:
+    """A page whose guessed encoding Python can't decode submits in UTF-8."""
+    detector = Mock(encodings=['EUC-TW'], declared_encoding=None)
+    target = 'crawlee.crawlers._beautifulsoup._beautifulsoup_crawling_context.EncodingDetector'
+
+    with patch(target, return_value=detector):
+        [request] = await extract_with_beautifulsoup(
+            f'<form><input name="q" value="{_CZECH}"></form>', content_type='text/html'
+        )
+
+    assert urlsplit(request.url).query == urlencode({'q': _CZECH})
+
+
+async def test_beautifulsoup_undeclared_selector() -> None:
+    """A selector is matched on the page decoded as for the forms, not as `BeautifulSoup` decoded it."""
+    # `BeautifulSoup` reads the page as UTF-7, which browsers don't know, and finds a form with the `first` ID.
+    html = '<meta charset="utf-7">+ADw-form id=first+AD4-+ADw-/form+AD4-<form action="/login"></form>'
+
+    assert await extract_with_beautifulsoup(html, content_type='text/html', selector='#first') == []
+
+
+async def test_parsel_undeclared_encoding() -> None:
+    """A page declaring no encoding submits in UTF-8 with Parsel."""
+    html = '<form><input name="q"></form>'
+
+    [request] = await extract_with_parsel(html, content_type='text/html', fields={'q': _CZECH})
+
+    assert urlsplit(request.url).query == urlencode({'q': _CZECH})
+
+
+async def test_parsel_json_response() -> None:
+    """A JSON response yields no requests with Parsel."""
+    body = '{"html": "<form action=\\"/a\\"></form>"}'
+
+    assert await extract_with_parsel(body, content_type='application/json') == []
diff --git a/tests/unit/crawlers/_beautifulsoup/test_beautifulsoup_crawler.py b/tests/unit/crawlers/_beautifulsoup/test_beautifulsoup_crawler.py
index f3bac73206..9d15ca3cd4 100644
--- a/tests/unit/crawlers/_beautifulsoup/test_beautifulsoup_crawler.py
+++ b/tests/unit/crawlers/_beautifulsoup/test_beautifulsoup_crawler.py
@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import sys
 from datetime import timedelta
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 from unittest import mock
 
 import pytest
@@ -314,6 +315,28 @@ async def request_handler(context: BeautifulSoupCrawlingContext) -> None:
     handler.assert_awaited_once_with([str(server_url.with_path(expected_path))])
 
 
+async def test_extract_form_requests(server_url: URL, http_client: HttpClient) -> None:
+    """A form request built in the handler submits the form fields with the `Referer` of the page."""
+    crawler = BeautifulSoupCrawler(http_client=http_client)
+    responses: list[dict[str, Any]] = []
+    page = '<form method="post" action="/post"><input type="hidden" name="token" value="t"><input name="q"></form>'
+
+    @crawler.router.default_handler
+    async def request_handler(context: BeautifulSoupCrawlingContext) -> None:
+        requests = await context.extract_form_requests(fields={'q': 'x'}, label='result')
+        await context.add_requests(requests)
+
+    @crawler.router.handler('result')
+    async def result_handler(context: BeautifulSoupCrawlingContext) -> None:
+        responses.append(json.loads(await context.http_response.read()))
+
+    await crawler.run([str((server_url / 'echo_content').with_query(content=page))])
+
+    [response] = responses
+    assert response['form'] == {'token': 't', 'q': 'x'}
+    assert response['headers']['referer'].startswith(str(server_url / 'echo_content'))
+
+
 async def test_extract_non_href_links(server_url: URL, http_client: HttpClient) -> None:
     crawler = BeautifulSoupCrawler(http_client=http_client)
     extracted_links: list[str] = []
diff --git a/tests/unit/crawlers/_parsel/test_parsel_crawler.py b/tests/unit/crawlers/_parsel/test_parsel_crawler.py
index 51613346c0..a37d6b9a71 100644
--- a/tests/unit/crawlers/_parsel/test_parsel_crawler.py
+++ b/tests/unit/crawlers/_parsel/test_parsel_crawler.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import codecs
+import json
 import sys
 from typing import TYPE_CHECKING, Any
 from unittest import mock
@@ -402,6 +403,28 @@ async def request_handler(context: ParselCrawlingContext) -> None:
     handler.assert_awaited_once_with([str(server_url.with_path(expected_path))])
 
 
+async def test_extract_form_requests(server_url: URL, http_client: HttpClient) -> None:
+    """A form request built in the handler submits the form fields with the `Referer` of the page."""
+    crawler = ParselCrawler(http_client=http_client)
+    responses: list[dict[str, Any]] = []
+    page = '<form method="post" action="/post"><input type="hidden" name="token" value="t"><input name="q"></form>'
+
+    @crawler.router.default_handler
+    async def request_handler(context: ParselCrawlingContext) -> None:
+        requests = await context.extract_form_requests(fields={'q': 'x'}, label='result')
+        await context.add_requests(requests)
+
+    @crawler.router.handler('result')
+    async def result_handler(context: ParselCrawlingContext) -> None:
+        responses.append(json.loads(await context.http_response.read()))
+
+    await crawler.run([str((server_url / 'echo_content').with_query(content=page))])
+
+    [response] = responses
+    assert response['form'] == {'token': 't', 'q': 'x'}
+    assert response['headers']['referer'].startswith(str(server_url / 'echo_content'))
+
+
 async def test_extract_non_href_links(server_url: URL, http_client: HttpClient) -> None:
     crawler = ParselCrawler(http_client=http_client)
     extracted_links: list[str] = []