@@ -0,0 +1,363 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, NamedTuple, TypedDict
+from urllib.parse import urlencode, urlsplit
+
+from pydantic import ValidationError
+
+from crawlee._request import Request
+from crawlee._types import HttpHeaders
+from crawlee._utils.crypto import compute_short_hash
+from crawlee._utils.html import resolve_encoding
+from crawlee._utils.urls import convert_to_absolute_url, 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 EnqueueStrategy, JsonSerializable
+
+_FIELD_TAGS = ('input', 'button', 'select', 'textarea')
+_BUTTON_INPUT_TYPES = ('submit', 'image', 'reset', 'button')
+
+
+class FormRequestOptions(TypedDict):
+    """Options for the `Request` created from a form.
+
+    Mirrors `RequestOptions` without the URL, method and payload, which come from the form, and without `id` and
+    `unique_key`, which can't be shared by several forms.
+    """
+
+    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. A `Content-Type` set here replaces the one of a POST form."""
+
+    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."""
+
+    enqueue_strategy: NotRequired[EnqueueStrategy]
+    """The strategy used when enqueuing the request."""
+
+    max_retries: NotRequired[int | None]
+    """The maximum number of retries of the request."""
+
+
+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,
+    **kwargs: Unpack[FormRequestOptions],
+) -> list[Request]:
+    """Create a `Request` submitting each form the way a browser does.
+
+    Dialog forms and forms not submitting over HTTP(S) are skipped. POST forms send their `Content-Type` and use
+    an extended unique key by default.
+
+    Args:
+        forms: The form elements, each within the lxml tree of the whole page.
+        page_url: The URL of the page.
+        page_encoding: The Python codec the page was decoded with, which forms submit in by default.
+        fields: Field values replacing those in the form or adding new fields. A `None` value drops the field and
+            a sequence submits the field once per value.
+        click: The submit button to click: `True` for the first one, `False` for none, or a mapping of attributes
+            the button must have, in which case forms without such a button are skipped.
+        **kwargs: Additional options passed to `Request.from_url`.
+    """
+    if not forms:
+        return []
+
+    root = forms[0].getroottree().getroot()
+    base = root.find('.//base[@href]')
+    try:
+        base_url = convert_to_absolute_url(page_url, '' if base is None else base.get('href'))
+    except ValueError:
+        base_url = page_url
+
+    elements_by_form = _elements_by_form(root)
+
+    requests = []
+    for form in forms:
+        request = _form_to_request(
+            form,
+            elements_by_form.get(form, []),
+            page_url=page_url,
+            base_url=base_url,
+            page_encoding=page_encoding,
+            fields=fields,
+            click=click,
+            **kwargs,
+        )
+        if request is not None:
+            requests.append(request)
+    return requests
+
+
+class _Field(NamedTuple):
+    """A single entry the form submits."""
+
+    name: str
+    value: str
+    is_file: bool = False
+
+
+def _elements_by_form(root: HtmlElement) -> dict[HtmlElement, list[HtmlElement]]:
+    """Group the fields and buttons of the page by the form they belong to, in document order."""
+    elements = list(root.iter(*_FIELD_TAGS))
+
+    # 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]'):
+            elements_by_id.setdefault(element.get('id'), element)
+
+    elements_by_form: dict[HtmlElement, list[HtmlElement]] = {}
+    for element in elements:
+        owner = _form_owner(element, elements_by_id)
+        if owner is not None:
+            elements_by_form.setdefault(owner, []).append(element)
+    return elements_by_form
+
+
+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 _form_to_request(
+    form: HtmlElement,
+    elements: list[HtmlElement],
+    *,
+    page_url: str,
+    base_url: str,
+    page_encoding: str,
+    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)
+        if click is not True 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_url, base_url, action)
+    if url is None:
+        return None
+
+    entries = _collect_fields(elements, button, fields)
+    encoding = _form_encoding(form, page_encoding)
+
+    if method != 'POST':
+        query = urlencode(
+            [(entry.name, entry.value) for entry in entries], encoding=encoding, errors='xmlcharrefreplace'
+        )
+        return Request.from_url(urlsplit(url)._replace(query=query).geturl(), method='GET', **kwargs)
+
+    payload, content_type = _encode_body(entries, enctype, encoding)
+    # The `Content-Type` passed in `headers` wins over the form's.
+    kwargs['headers'] = HttpHeaders({'Content-Type': content_type}) | 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]) -> HtmlElement | None:
+    """Find the first enabled submit button having all the given attributes."""
+    for element in elements:
+        if not _is_submit_button(element) or _is_disabled(element):
+            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':
+        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 _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_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:
+        return validate_http_url(convert_to_absolute_url(base_url, action))
+    except (ValueError, ValidationError):
+        return None
+
+
+def _collect_fields(
+    elements: list[HtmlElement],
+    button: HtmlElement | None,
+    fields: Mapping[str, str | Sequence[str] | None] | None,
+) -> 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 _is_disabled(element):
+            continue
+        if _is_radio(element) and checked_radios.get(element.get('name')) is not element:
+            continue
+        entries.extend(_element_fields(element))
+
+    return _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.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':
+        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 _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 _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}"'
+        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}'