diff --git a/src/crawlee/_utils/forms.py b/src/crawlee/_utils/forms.py
new file mode 100644
index 0000000000..3a0d569df0
--- /dev/null
+++ b/src/crawlee/_utils/forms.py
@@ -0,0 +1,451 @@
+from __future__ import annotations
+
+import codecs
+import re
+from contextlib import suppress
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, NamedTuple, TypedDict
+from urllib.parse import urlencode
+
+from lxml.html import HTMLParser, document_fromstring
+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.urls import convert_to_absolute_url
+
+if TYPE_CHECKING:
+    from collections.abc import Iterable, Mapping, Sequence
+
+    from lxml.html import HtmlElement
+    from typing_extensions import NotRequired, Unpack
+
+    from crawlee._types import EnqueueStrategy, HttpMethod, JsonSerializable
+
+_CHARSET_PATTERN = re.compile(r'charset\s*=\s*["\']?([^"\'\s;]+)', re.IGNORECASE)
+
+# Legacy charsets browsers replace with a superset, per the WHATWG Encoding Standard.
+_ENCODING_SUPERSETS = {
+    'ascii': 'cp1252',
+    'iso8859-1': 'cp1252',
+    'iso8859-9': 'cp1254',
+    'iso8859-11': 'cp874',
+    'tis-620': 'cp874',
+    'gb2312': 'gbk',
+    'shift_jis': 'cp932',
+    'euc_kr': 'cp949',
+}
+
+_FIELD_TAGS = ('input', 'button', 'select', 'textarea')
+_BUTTON_INPUT_TYPES = ('submit', 'image', 'reset', 'button')
+
+# Browsers percent-encode these characters in multipart field names.
+_MULTIPART_NAME_ESCAPES = str.maketrans({'"': '%22', '\r': '%0D', '\n': '%0A'})
+
+
+class FormRequestOptions(TypedDict):
+    """Options for the `Request` created from a form, other than the URL, method and payload taken from the form."""
+
+    label: NotRequired[str | None]
+    session_id: NotRequired[str | None]
+    unique_key: NotRequired[str | None]
+    keep_url_fragment: NotRequired[bool]
+    use_extended_unique_key: NotRequired[bool]
+    always_enqueue: NotRequired[bool]
+    user_data: NotRequired[Mapping[str, JsonSerializable]]
+    no_retry: NotRequired[bool]
+    enqueue_strategy: NotRequired[EnqueueStrategy]
+    max_retries: NotRequired[int | None]
+
+
+def forms_to_requests(
+    forms: Iterable[HtmlElement],
+    page_url: str,
+    content_type: str | None,
+    *,
+    form_data: Mapping[str, str | Sequence[str] | None] | None = None,
+    click_data: Mapping[str, str] | None = None,
+    dont_click: bool = False,
+    headers: HttpHeaders | dict[str, str] | None = None,
+    **kwargs: Unpack[FormRequestOptions],
+) -> list[Request]:
+    """Create a `Request` submitting each form the way a browser does.
+
+    Forms with no submit button matching `click_data`, dialog forms and forms not submitting over HTTP(S) are skipped.
+
+    Args:
+        forms: The form elements, each within the lxml tree of the whole page.
+        page_url: The URL of the page.
+        content_type: The `Content-Type` header of the page response, used to find the page encoding.
+        form_data: Field values overriding those in the form. A `None` value drops the field.
+        click_data: Attributes identifying the submit button to click. Defaults to the first one.
+        dont_click: Submit the form without clicking any button.
+        headers: The HTTP headers of the request. The `Content-Type` of the form is added to them.
+        **kwargs: Additional options passed to `Request.from_url`.
+    """
+    forms = list(forms)
+    if not forms:
+        return []
+
+    page = _analyze_page(forms[0].getroottree().getroot(), page_url, content_type)
+
+    requests = []
+    for form in forms:
+        request = _form_to_request(
+            form,
+            page,
+            form_data=form_data,
+            click_data=click_data,
+            dont_click=dont_click,
+            headers=headers,
+            **kwargs,
+        )
+        if request is not None:
+            requests.append(request)
+    return requests
+
+
+def parse_html(body: bytes, encoding: str | None) -> HtmlElement:
+    """Parse a page with lxml, decoding it with the given encoding, or the one lxml detects if it's `None`."""
+    try:
+        parser = HTMLParser(encoding=encoding)
+    except LookupError:
+        # A codec Python knows but libxml2 doesn't, so let lxml detect the encoding itself.
+        parser = HTMLParser()
+    return document_fromstring(body, parser=parser)
+
+
+def response_charset(content_type: str | None) -> str | None:
+    """Get the charset from a `Content-Type` header, if it names a known one."""
+    charset = _find_charset(content_type)
+    if charset is None:
+        return None
+    with suppress(LookupError):
+        return codecs.lookup(charset).name
+    return None
+
+
+class _Field(NamedTuple):
+    """A single entry the form submits."""
+
+    name: str
+    value: str
+    is_file: bool = False
+
+
+@dataclass
+class _Page:
+    """The parts of a page shared by all its forms, computed in a single pass over the document."""
+
+    url: str
+    base_url: str
+    charsets: list[str]
+    """The page encoding candidates, from the `Content-Type` header and then the `<meta>` tags."""
+    elements_by_form: dict[HtmlElement, list[HtmlElement]]
+    """The fields and buttons belonging to each form, in document order."""
+
+
+def _analyze_page(root: HtmlElement, page_url: str, content_type: str | None) -> _Page:
+    """Resolve the base URL, encoding candidates and form owners of all fields on the page."""
+    try:
+        base_url = convert_to_absolute_url(page_url, root.xpath('string(//base[@href][1]/@href)'))
+    except ValueError:
+        base_url = page_url
+
+    # The first element with a given ID wins, as in `getElementById`.
+    elements_by_id: dict[str, HtmlElement] = {}
+    for element in root.xpath('//*[@id]'):
+        elements_by_id.setdefault(element.get('id'), element)
+
+    elements_by_form: dict[HtmlElement, list[HtmlElement]] = {}
+    for element in root.iter(*_FIELD_TAGS):
+        owner = _form_owner(element, elements_by_id)
+        if owner is not None:
+            elements_by_form.setdefault(owner, []).append(element)
+
+    return _Page(
+        url=page_url,
+        base_url=base_url,
+        charsets=_page_charsets(root, content_type),
+        elements_by_form=elements_by_form,
+    )
+
+
+def _page_charsets(root: HtmlElement, content_type: str | None) -> list[str]:
+    """Collect the charsets the page declares, in the order browsers trust them."""
+    charsets: list[str] = []
+
+    header_charset = _find_charset(content_type)
+    if header_charset is not None:
+        charsets.append(header_charset)
+
+    charsets.extend(root.xpath('//meta[@charset]/@charset'))
+
+    http_equiv_contents = root.xpath(
+        '//meta[translate(@http-equiv, "CONTENT-TYP", "content-typ")="content-type"]/@content'
+    )
+    for content in http_equiv_contents:
+        meta_charset = _find_charset(content)
+        if meta_charset is not None:
+            charsets.append(meta_charset)
+
+    return charsets
+
+
+def _find_charset(value: str | None) -> str | None:
+    """Find the `charset=` parameter in a `Content-Type` value."""
+    if not value:
+        return None
+    match = _CHARSET_PATTERN.search(value)
+    return match.group(1) if match else None
+
+
+def _form_to_request(
+    form: HtmlElement,
+    page: _Page,
+    *,
+    form_data: Mapping[str, str | Sequence[str] | None] | None,
+    click_data: Mapping[str, str] | None,
+    dont_click: bool,
+    headers: HttpHeaders | dict[str, str] | None,
+    **kwargs: Unpack[FormRequestOptions],
+) -> Request | None:
+    """Create a `Request` submitting a single form, or `None` if a browser wouldn't send one."""
+    elements = page.elements_by_form.get(form, [])
+
+    if dont_click:
+        button = None
+    else:
+        button = _find_clickable(elements, click_data)
+        if click_data and 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').strip()
+
+    # A dialog form only closes its `<dialog>` on the client.
+    if method == 'DIALOG':
+        return None
+
+    url = _resolve_action(page, action)
+    if url is None:
+        return None
+
+    fields = _collect_fields(elements, button, form_data)
+    encoding = _form_encoding(form, page.charsets)
+    request_headers = HttpHeaders(headers or {})
+
+    if method != 'POST':
+        get_url = _url_with_query(url, fields, encoding)
+        return Request.from_url(get_url, method='GET', headers=request_headers, **kwargs)
+
+    payload, content_type = _encode_body(fields, enctype, encoding)
+    request_method: HttpMethod = 'POST'
+    kwargs.setdefault('use_extended_unique_key', True)
+    return Request.from_url(
+        url,
+        method=request_method,
+        headers=HttpHeaders({'Content-Type': content_type}) | request_headers,
+        payload=payload,
+        **kwargs,
+    )
+
+
+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."""
+    if button is not None:
+        button_value = button.get(f'form{name}')
+        if button_value:
+            return button_value
+    return form.get(name) or ''
+
+
+def _resolve_action(page: _Page, action: str) -> str | None:
+    """Resolve the form action to an absolute URL, or `None` if it can't be submitted over HTTP(S)."""
+    if not action:
+        return page.url
+
+    try:
+        url = convert_to_absolute_url(page.base_url, action)
+    except ValueError:
+        return None
+
+    if URL(url).scheme not in ('http', 'https'):
+        return None
+    return url
+
+
+def _url_with_query(url: str, fields: list[_Field], encoding: str) -> str:
+    """Replace the query of the URL with the fields, as a GET form does."""
+    query = urlencode([(field.name, field.value) for field in fields], encoding=encoding, errors='xmlcharrefreplace')
+    parsed = URL(url)
+    # Build the URL from raw parts, as `with_query` would encode the query again as UTF-8.
+    return str(
+        URL.build(
+            scheme=parsed.scheme,
+            authority=parsed.raw_authority,
+            path=parsed.raw_path,
+            query_string=query,
+            fragment=parsed.raw_fragment,
+            encoded=True,
+        )
+    )
+
+
+def _encode_body(fields: 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(fields, encoding)
+
+    if enctype == 'text/plain':
+        text = ''.join(f'{field.name}={field.value}\r\n' for field in fields)
+        return text.encode(encoding, 'xmlcharrefreplace'), 'text/plain'
+
+    pairs = [(field.name, field.value) for field in fields]
+    body = urlencode(pairs, encoding=encoding, errors='xmlcharrefreplace').encode()
+    return body, 'application/x-www-form-urlencoded'
+
+
+def _form_owner(element: HtmlElement, elements_by_id: Mapping[str, HtmlElement]) -> HtmlElement | None:
+    """Get the form an element belongs to, honouring its `form` attribute."""
+    form_id = element.get('form')
+    if form_id is None:
+        return next(element.iterancestors('form'), None)
+
+    owner = elements_by_id.get(form_id)
+    if owner is None or owner.tag != 'form':
+        return None
+    return owner
+
+
+def _find_clickable(elements: list[HtmlElement], click_data: Mapping[str, str] | None) -> HtmlElement | None:
+    """Find the submit button to click, matching all attributes in `click_data`."""
+    for element in elements:
+        if not _is_submit_button(element) or _is_disabled(element):
+            continue
+        if not click_data:
+            return element
+        if all(element.get(key) == value for key, value in click_data.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':
+        return button_type in ('', 'submit')
+    if element.tag == 'input':
+        return button_type in ('submit', 'image')
+    return False
+
+
+def _is_disabled(element: HtmlElement) -> bool:
+    """Check whether the element, or a `<fieldset>` containing it, is disabled."""
+    if 'disabled' in element.attrib:
+        return True
+    return any('disabled' in fieldset.attrib for fieldset in element.iterancestors('fieldset'))
+
+
+def _collect_fields(
+    elements: list[HtmlElement],
+    button: HtmlElement | None,
+    form_data: Mapping[str, str | Sequence[str] | None] | None,
+) -> list[_Field]:
+    """Collect the entries the form submits: its fields, the clicked button and the `form_data` overrides."""
+    fields: list[_Field] = []
+    for element in elements:
+        if element.get('name') and not _is_disabled(element):
+            fields.extend(_element_fields(element))
+
+    if button is not None:
+        fields.extend(_button_fields(button))
+
+    if form_data:
+        fields = _apply_form_data(fields, form_data)
+
+    return fields
+
+
+def _element_fields(element: HtmlElement) -> list[_Field]:
+    """Get the entries a single enabled, named field submits."""
+    name = element.get('name')
+
+    if element.tag == 'select':
+        values = element.value if element.multiple else [element.value]
+        return [_Field(name, value) for value in values if value is not None]
+
+    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 []
+
+    return [_Field(name, element.value or '')]
+
+
+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 _apply_form_data(fields: list[_Field], form_data: Mapping[str, str | Sequence[str] | None]) -> list[_Field]:
+    """Replace the fields named in `form_data` with its values, dropping those set to `None`."""
+    result = [field for field in fields if field.name not in form_data]
+    for name, value in form_data.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_charsets: list[str]) -> str:
+    """Pick the encoding a browser submits the form in: `accept-charset`, then the page encoding, then UTF-8."""
+    accept_charsets = (form.get('accept-charset') or '').replace(',', ' ').split()
+
+    for candidate in [*accept_charsets, *page_charsets]:
+        with suppress(LookupError, UnicodeError):
+            name = codecs.lookup(candidate).name
+            # Skip codecs that can't encode text with character references, like `base64` or `idna`.
+            ''.encode(name, 'xmlcharrefreplace')
+            return _ENCODING_SUPERSETS.get(name, name)
+
+    return 'utf-8'
+
+
+def _encode_multipart(fields: 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 field in fields:
+        disposition = f'form-data; name="{field.name.translate(_MULTIPART_NAME_ESCAPES)}"'
+        if field.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 + field.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..5a0db8e2e9 100644
--- a/src/crawlee/crawlers/_beautifulsoup/_beautifulsoup_crawling_context.py
+++ b/src/crawlee/crawlers/_beautifulsoup/_beautifulsoup_crawling_context.py
@@ -1,13 +1,26 @@
+from __future__ import annotations
+
+import asyncio
 from dataclasses import dataclass, fields
+from typing import TYPE_CHECKING
 
 from bs4 import BeautifulSoup
-from typing_extensions import Self
 
 from crawlee._utils.docs import docs_group
+from crawlee._utils.forms import forms_to_requests, parse_html, response_charset
 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._types import HttpHeaders
+    from crawlee._utils.forms import FormRequestOptions
+
 
 @dataclass(frozen=True)
 @docs_group('Crawling contexts')
@@ -30,3 +43,64 @@ 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 form_requests(
+        self,
+        selector: str = 'form',
+        *,
+        form_data: Mapping[str, str | Sequence[str] | None] | None = None,
+        click_data: Mapping[str, str] | None = None,
+        dont_click: bool = False,
+        headers: HttpHeaders | dict[str, str] | None = None,
+        **kwargs: Unpack[FormRequestOptions],
+    ) -> list[Request]:
+        """Create a `Request` submitting each form on the page, the way a browser does.
+
+        Forms with no submit button matching `click_data`, dialog forms and forms not submitting over HTTP(S) are
+        skipped. The page is parsed again with lxml from the raw response body, so the forms don't depend on the
+        parser `BeautifulSoup` was created with.
+
+        Args:
+            selector: CSS selector for the forms to submit.
+            form_data: Field values overriding those in the form. A `None` value drops the field.
+            click_data: Attributes identifying the submit button to click. Defaults to the first one.
+            dont_click: Submit the form without clicking any button.
+            headers: The HTTP headers of the request. The `Content-Type` of the form is added to them.
+            **kwargs: Additional options passed to `Request.from_url`.
+        """
+        body = await self.http_response.read()
+        content_type = self.http_response.headers.get('content-type')
+        header_charset = response_charset(content_type)
+
+        def build_requests() -> list[Request]:
+            # Fields are read from an lxml tree of the page, whose forms are matched to the soup ones by position.
+            # That only holds for a soup built by lxml, so other parsers need a re-parse.
+            if self.soup.builder.NAME == 'lxml':
+                soup = self.soup
+            else:
+                soup = BeautifulSoup(body, 'lxml', from_encoding=header_charset)
+
+            selected = [tag for tag in soup.select(selector) if tag.name == 'form']
+            if not selected:
+                return []
+
+            # The header charset wins, as in browsers. Otherwise decode like the soup, which also sniffs pages that
+            # don't declare an encoding. The outdated `types-beautifulsoup4` stubs resolve `original_encoding` as a tag.
+            encoding = header_charset or soup.original_encoding
+            lxml_forms = list(parse_html(body, encoding).iter('form'))  # ty: ignore[invalid-argument-type]
+
+            position_by_form = {id(form): position for position, form in enumerate(soup.find_all('form'))}
+            forms = [lxml_forms[position_by_form[id(form)]] for form in selected]
+
+            return forms_to_requests(
+                forms,
+                self.request.loaded_url or self.request.url,
+                content_type,
+                form_data=form_data,
+                click_data=click_data,
+                dont_click=dont_click,
+                headers=headers,
+                **kwargs,
+            )
+
+        return await asyncio.to_thread(build_requests)
diff --git a/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py b/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py
index c29b9499d0..29cf38074d 100644
--- a/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py
+++ b/src/crawlee/crawlers/_parsel/_parsel_crawling_context.py
@@ -1,13 +1,25 @@
+from __future__ import annotations
+
 from dataclasses import dataclass, fields
+from typing import TYPE_CHECKING
 
 from parsel import Selector
-from typing_extensions import Self
 
 from crawlee._utils.docs import docs_group
+from crawlee._utils.forms import forms_to_requests
 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._types import HttpHeaders
+    from crawlee._utils.forms import FormRequestOptions
+
 
 @dataclass(frozen=True)
 @docs_group('Crawling contexts')
@@ -30,3 +42,44 @@ 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 form_requests(
+        self,
+        selector: str = 'form',
+        *,
+        form_data: Mapping[str, str | Sequence[str] | None] | None = None,
+        click_data: Mapping[str, str] | None = None,
+        dont_click: bool = False,
+        headers: HttpHeaders | dict[str, str] | None = None,
+        **kwargs: Unpack[FormRequestOptions],
+    ) -> list[Request]:
+        """Create a `Request` submitting each form on the page, the way a browser does.
+
+        Forms with no submit button matching `click_data`, dialog forms and forms not submitting over HTTP(S) are
+        skipped.
+
+        Args:
+            selector: CSS selector for the forms to submit.
+            form_data: Field values overriding those in the form. A `None` value drops the field.
+            click_data: Attributes identifying the submit button to click. Defaults to the first one.
+            dont_click: Submit the form without clicking any button.
+            headers: The HTTP headers of the request. The `Content-Type` of the form is added to them.
+            **kwargs: Additional options passed to `Request.from_url`.
+        """
+        forms = []
+        for match in self.selector.css(selector):
+            # The selector can also match text or attributes, whose root is a plain string.
+            element = match.root
+            if getattr(element, 'tag', None) == 'form':
+                forms.append(element)
+
+        return forms_to_requests(
+            forms,
+            self.request.loaded_url or self.request.url,
+            self.http_response.headers.get('content-type'),
+            form_data=form_data,
+            click_data=click_data,
+            dont_click=dont_click,
+            headers=headers,
+            **kwargs,
+        )
diff --git a/tests/unit/_utils/test_forms.py b/tests/unit/_utils/test_forms.py
new file mode 100644
index 0000000000..928453564d
--- /dev/null
+++ b/tests/unit/_utils/test_forms.py
@@ -0,0 +1,473 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+from unittest.mock import AsyncMock, Mock
+from urllib.parse import parse_qsl, urlsplit
+
+import pytest
+from bs4 import BeautifulSoup
+from parsel import Selector
+
+from crawlee import HttpHeaders, Request
+from crawlee._utils.forms import response_charset
+from crawlee.crawlers import BeautifulSoupCrawlingContext, ParselCrawlingContext
+
+if TYPE_CHECKING:
+    from collections.abc import Awaitable, Callable
+
+    FormRequests = Callable[..., Awaitable[list[Request]]]
+
+_PAGE_URL = 'https://example.com/page/index.html'
+
+
+def _context(html: str, page_request: Request | None, content_type: str | None, encoding: str | None) -> Mock:
+    body = html.encode(encoding or response_charset(content_type) 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 _parsel_form_requests(
+    html: str,
+    page_request: Request | None = None,
+    content_type: str | None = None,
+    encoding: str | None = None,
+    **kwargs: Any,
+) -> list[Request]:
+    context = _context(html, page_request, content_type, encoding)
+    context.selector = Selector(text=html)
+    return await ParselCrawlingContext.form_requests(context, **kwargs)
+
+
+def _beautifulsoup_form_requests(parser: str) -> FormRequests:
+    async def form_requests(
+        html: str,
+        page_request: Request | None = None,
+        content_type: str | None = None,
+        encoding: str | None = None,
+        **kwargs: Any,
+    ) -> list[Request]:
+        context = _context(html, page_request, content_type, encoding)
+        # Built from the raw body like `BeautifulSoupParser` does, so `original_encoding` is set.
+        context.soup = BeautifulSoup(await context.http_response.read(), parser)
+        return await BeautifulSoupCrawlingContext.form_requests(context, **kwargs)
+
+    return form_requests
+
+
+@pytest.fixture(
+    params=[
+        pytest.param(_parsel_form_requests, id='parsel'),
+        pytest.param(_beautifulsoup_form_requests('lxml'), id='beautifulsoup-lxml'),
+        pytest.param(_beautifulsoup_form_requests('html5lib'), id='beautifulsoup-html5lib'),
+    ]
+)
+def form_requests(request: pytest.FixtureRequest) -> FormRequests:
+    return request.param
+
+
+def _form_values(request: Request) -> list[tuple[str, str]]:
+    if request.method == 'GET':
+        return parse_qsl(urlsplit(request.url).query, keep_blank_values=True)
+    assert request.payload is not None
+    return parse_qsl(request.payload.decode(), keep_blank_values=True)
+
+
+async def _single(form_requests: FormRequests, html: str, **kwargs: Any) -> Request:
+    [request] = await form_requests(html, **kwargs)
+    return request
+
+
+async def test_get_form_puts_fields_in_query(form_requests: FormRequests) -> None:
+    """A GET form replaces the query of its action with the fields."""
+    html = '<form action="/search?old=1"><input name="q" value="shoes"><input name="page" value="2"></form>'
+
+    request = await _single(form_requests, html)
+
+    assert request.method == 'GET'
+    assert request.payload is None
+    assert request.url == 'https://example.com/search?q=shoes&page=2'
+
+
+async def test_post_form_is_urlencoded(form_requests: FormRequests) -> None:
+    """A POST form sends the fields as an urlencoded body."""
+    html = '<form method="post" action="login"><input name="user" value="a b"><input name="pass" value="&"></form>'
+
+    request = await _single(form_requests, html)
+
+    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'
+
+
+async def test_post_forms_with_different_data_are_distinct(form_requests: FormRequests) -> None:
+    """POST requests to the same action with different data get different unique keys."""
+    html = '<form method="post"><input name="page" value="1"></form>'
+
+    first = await _single(form_requests, html)
+    second = await _single(form_requests, html, form_data={'page': '2'})
+
+    assert first.unique_key != second.unique_key
+
+
+async def test_field_collection(form_requests: FormRequests) -> 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="radio" name="radio" value="r1">
+        <input type="radio" name="radio" value="r2" checked>
+        <select name="first"><option value="o1">1</option><option value="o2">2</option></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">long 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 _single(form_requests, html)
+
+    assert _form_values(request) == [
+        ('text', 't'),
+        ('checked', 'c1'),
+        ('no-value', 'on'),
+        ('radio', 'r2'),
+        ('first', 'o1'),
+        ('multi', 'm1'),
+        ('multi', 'm3'),
+        ('area', 'long text'),
+        ('file', ''),
+        ('empty', ''),
+        ('hidden', ''),
+    ]
+
+
+async def test_select_options(form_requests: FormRequests) -> None:
+    """A select submits its last selected option, or the first enabled one when none is selected."""
+    html = """
+    <form>
+        <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="empty"></select>
+    </form>
+    """
+
+    request = await _single(form_requests, html)
+
+    assert _form_values(request) == [('last', 'b'), ('first-enabled', 'on')]
+
+
+async def test_fields_linked_by_form_attribute(form_requests: FormRequests) -> None:
+    """Fields are assigned to forms by their `form` attribute."""
+    html = """
+    <form id="search" action="/search"><input name="q" value="x"><input name="other" value="o" form="login"></form>
+    <select name="lang" form="search"><option value="en" selected>EN</option></select>
+    <button form="search" name="go" value="1">Go</button>
+    <input name="orphan" value="z" form="missing">
+    <form id="login" action="/login"></form>
+    """
+
+    search, login = await form_requests(html)
+
+    assert _form_values(search) == [('q', 'x'), ('lang', 'en'), ('go', '1')]
+    assert _form_values(login) == [('other', 'o')]
+
+
+async def test_disabled_fieldset_around_form(form_requests: FormRequests) -> None:
+    """A disabled `<fieldset>` around the form disables its fields."""
+    html = '<fieldset disabled><form><input name="a" value="1"></form></fieldset>'
+
+    request = await _single(form_requests, html)
+
+    assert _form_values(request) == []
+
+
+async def test_dialog_form_is_skipped(form_requests: FormRequests) -> None:
+    """Dialog forms send no request."""
+    html = '<dialog open><form method="dialog"><button>Close</button></form></dialog><form action="/ok"></form>'
+
+    assert [urlsplit(request.url).path for request in await form_requests(html)] == ['/ok']
+
+
+@pytest.mark.parametrize(
+    ('html', 'content_type', 'encoding'),
+    [
+        pytest.param(
+            '<form accept-charset="bogus windows-1251"><input name="q" value="{value}"></form>',
+            None,
+            'utf-8',
+            id='accept-charset',
+        ),
+        pytest.param(
+            '<form><input name="q" value="{value}"></form>',
+            'text/html; charset=windows-1251',
+            'windows-1251',
+            id='header',
+        ),
+        pytest.param(
+            '<head><meta charset="windows-1251"></head><form><input name="q" value="{value}"></form>',
+            None,
+            'windows-1251',
+            id='meta-charset',
+        ),
+        pytest.param(
+            '<head><meta http-equiv="Content-Type" content="text/html; charset=windows-1251"></head>'
+            '<form><input name="q" value="{value}"></form>',
+            None,
+            'windows-1251',
+            id='meta-http-equiv',
+        ),
+    ],
+)
+@pytest.mark.parametrize('method', [pytest.param('get', id='get'), pytest.param('post', id='post')])
+async def test_form_encoding(
+    form_requests: FormRequests, html: str, content_type: str | None, encoding: str, method: str
+) -> None:
+    """Values are encoded in the form or page charset, with unsupported characters as character references."""
+    html = html.format(value='привіт ✓').replace('<form', f'<form method="{method}"', 1)
+
+    request = await _single(form_requests, html, content_type=content_type, encoding=encoding)
+
+    encoded = request.url.split('?')[1] if method == 'get' else (request.payload or b'').decode()
+    assert encoded == 'q=%EF%F0%E8%E2%B3%F2+%26%2310003%3B'
+
+
+async def test_form_data_overrides_fields(form_requests: FormRequests) -> None:
+    """Values from `form_data` 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 _single(form_requests, html, form_data={'replace': 'new', 'drop': None, 'tags': ['a', 'b']})
+
+    assert _form_values(request) == [('keep', 'k'), ('replace', 'new'), ('tags', 'a'), ('tags', 'b')]
+
+
+async def test_first_submit_button_is_clicked(form_requests: FormRequests) -> None:
+    """The first enabled submit button is included by default."""
+    html = """
+    <form>
+        <input name="q" value="x">
+        <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 name="go" value="first">Go</button>
+        <input type="submit" name="go" value="second">
+    </form>
+    """
+
+    request = await _single(form_requests, html)
+
+    assert _form_values(request) == [('q', 'x'), ('go', 'first')]
+
+
+async def test_click_data_selects_button(form_requests: FormRequests) -> None:
+    """`click_data` picks the button to click and its form 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 _single(form_requests, html, click_data={'value': 'delete'})
+
+    assert request.method == 'POST'
+    assert request.url == 'https://example.com/delete'
+    assert _form_values(request) == [('q', 'x'), ('action', 'delete')]
+
+
+async def test_dont_click(form_requests: FormRequests) -> None:
+    """`dont_click` leaves out every button."""
+    html = '<form><input name="q" value="x"><input type="submit" name="go" value="1"></form>'
+
+    request = await _single(form_requests, html, dont_click=True)
+
+    assert _form_values(request) == [('q', 'x')]
+
+
+async def test_image_button_sends_coordinates(form_requests: FormRequests) -> None:
+    """A clicked image button sends its click coordinates."""
+    html = '<form><input type="image" name="map" src="map.png"></form>'
+
+    request = await _single(form_requests, html)
+
+    assert _form_values(request) == [('map.x', '0'), ('map.y', '0')]
+
+
+async def test_click_data_skips_unmatched_forms(form_requests: FormRequests) -> None:
+    """Forms with no button matching `click_data` are skipped."""
+    html = '<form action="/search"><input name="q"></form><form action="/save"><button name="go">Go</button></form>'
+
+    assert [urlsplit(request.url).path for request in await form_requests(html, click_data={'name': 'go'})] == ['/save']
+    assert await form_requests(html, click_data={'name': 'missing'}) == []
+
+
+async def test_non_http_action_is_skipped(form_requests: FormRequests) -> None:
+    """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="/ok"></form>'
+    )
+
+    assert [urlsplit(request.url).path for request in await form_requests(html)] == ['/ok']
+
+
+async def test_multipart_form(form_requests: FormRequests) -> 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 _single(form_requests, html)
+    again = await _single(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_text_plain_form(form_requests: FormRequests) -> 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 _single(form_requests, html)
+
+    assert request.headers['content-type'] == 'text/plain'
+    assert request.payload == b'a=1\r\nb=2\r\n'
+
+
+@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(
+            '<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',
+        ),
+    ],
+)
+async def test_action_resolution(form_requests: FormRequests, html: str, expected_url: str) -> None:
+    """The action is resolved against `<base href>`, and a missing action submits to the page URL."""
+    request = await _single(form_requests, html)
+
+    assert request.url == expected_url
+
+
+async def test_action_resolves_against_loaded_url(form_requests: FormRequests) -> 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 _single(form_requests, '<form action="go"></form>', page_request=page_request)
+
+    assert request.url == 'https://example.com/moved/go'
+
+
+async def test_textarea_leading_newline(form_requests: FormRequests) -> None:
+    """The newline right after `<textarea>` is dropped."""
+    request = await _single(form_requests, '<form><textarea name="a">\n\nhello</textarea></form>')
+
+    assert _form_values(request) == [('a', '\nhello')]
+
+
+async def test_selector_filters_forms(form_requests: FormRequests) -> None:
+    """All forms are used by default and `selector` narrows them."""
+    html = '<form id="a" action="/a"></form><div id="b"></div><form id="c" action="/c"></form>'
+
+    assert [urlsplit(request.url).path for request in await form_requests(html)] == ['/a', '/c']
+    assert [urlsplit(request.url).path for request in await form_requests(html, selector='#c, #b')] == ['/c']
+
+
+async def test_request_options_are_passed(form_requests: FormRequests) -> None:
+    """Headers and request options are applied to the request."""
+    html = '<form method="post"><input name="q" value="x"></form>'
+
+    request = await _single(form_requests, html, headers={'X-Custom': '1'}, label='detail')
+
+    assert request.headers['x-custom'] == '1'
+    assert request.headers['content-type'] == 'application/x-www-form-urlencoded'
+    assert request.label == 'detail'
+
+
+async def test_xml_declaration(form_requests: FormRequests) -> None:
+    """Pages starting with an XML declaration are supported."""
+    html = '<?xml version="1.0" encoding="UTF-8"?><html><body><form action="/ok"></form></body></html>'
+
+    assert [urlsplit(request.url).path for request in await form_requests(html)] == ['/ok']
+
+
+@pytest.mark.parametrize(
+    ('charset', 'value', 'expected_query'),
+    [
+        pytest.param('us-ascii', 'é€', 'q=%E9%80', id='ascii'),
+        pytest.param('iso-8859-1', 'é€', 'q=%E9%80', id='latin1'),
+        pytest.param('shift_jis', '①', 'q=%87%40', id='shift-jis'),
+    ],
+)
+async def test_legacy_charset_uses_superset(
+    form_requests: FormRequests, charset: str, value: str, expected_query: str
+) -> None:
+    """Legacy charsets are submitted in the superset browsers use instead."""
+    html = f'<form><input name="q" value="{value}"></form>'
+
+    request = await _single(form_requests, html, content_type=f'text/html; charset={charset}')
+
+    assert request.url.split('?')[1] == expected_query
+
+
+@pytest.mark.parametrize(
+    'charset',
+    [
+        pytest.param('base64', id='binary-codec'),
+        pytest.param('undefined', id='undefined'),
+        pytest.param('idna', id='idna'),
+    ],
+)
+async def test_non_text_charset_is_ignored(form_requests: FormRequests, charset: str) -> None:
+    """Charsets naming codecs that can't encode form data fall back to UTF-8."""
+    html = f'<form accept-charset="{charset}"><input name="q" value="é"></form>'
+
+    request = await _single(form_requests, html)
+
+    assert request.url == 'https://example.com/page/index.html?q=%C3%A9'