page_url

Changing a page's address on a live website is one of the few edits that can break things outside the system: existing links, bookmarks, search engine results. Odoo's answer is to show the consequences while you are still typing rather than after you have saved.

This widget is that field. It renders the site prefix beside the input so the address reads as a whole, hides the leading slash so what you edit is just the path, and adds it back before the value is stored, because the underlying field cannot be empty.

The more useful half is what it triggers. Typing fires a change event on a short delay, which lets the server recompute the page's dependencies and offer a redirect. So by the time you save, the form has already told you what points at this page and whether the old address will keep working.

Page renames are cheap to do and expensive to get wrong, and the cost lands on marketing rather than on the person who made the change. Surfacing dependencies at the moment of editing is the only intervention that reliably works, because it is the only one that happens before the decision.

The redirect offer matters just as much. A renamed page with no redirect loses whatever authority the old address had accumulated, and the people who notice are not the people who made the change. Having that offered inline, rather than as a separate configuration screen, is what makes it get used.

The practical advice for a site with traffic worth protecting is to treat this field as a decision point rather than a text box: read what the form tells you before saving, and take the redirect.

The core usage

<field name="url" widget="page_url"/>

No options. The prefix, the dependency panel and the redirect offer all come from the widget and its companion component.

What is stored

# typed:  contact-us
# stored: /contact-us

The leading slash is stripped for display and re-added before storage, so the field is never empty.

The plain link field

<field name="url" widget="url"
       options="{'website_path': True}"/>

Site-relative rendering without the dependency panel or the typing nudge.

Two implementation details in this widget are worth knowing, and both are unusual enough that they have survived into the development branch unchanged.

The first is how the slash is handled. The value getter strips a leading slash for display and then, in the same getter, writes the slash-prefixed value back into the record's data before returning the stripped one. Writing to the record from inside a getter is not how Odoo normally does things, and the source comment explains the constraint it works around: the field is required, so an empty string is not acceptable, and the user must be able to clear the path down to nothing while typing.

The second is the typing nudge. An effect attaches an input listener that, on a short debounce, compares the current value with the original and dispatches a synthetic change event when that comparison flips. That is what makes the server recompute dependencies and redirect options while the user types rather than on blur. The comment above it says outright that this should be handled more automatically by the framework, which is a candid marker of a workaround.

There is a small detail inside that listener: before dispatching, it temporarily prefixes a slash if the value has none, then restores what the user typed. So the server always sees a well-formed path even mid-edit.

Everything else, including the site prefix rendering and the link behavior, comes from the link field it extends, with the website path option defaulted on.

Odoo 20 is expected at Odoo Experience in Brussels, 24 to 26 September 2026. The development branch is unstable and this may still change; we re-verify the page after release.

One addition. A translation button joins the field's components, so a multilingual site can edit the address per language from the same place. The slash handling, including the write from inside the getter, and the typing nudge are unchanged.

The rest of the diff is the migration to the new props and reference helpers, which reshapes how the input listener is attached without changing what it does.