diff --git a/core/engine/src/builtins/iterable/mod.rs b/core/engine/src/builtins/iterable/mod.rs
index 837f6da38f1..c079ec12827 100644
--- a/core/engine/src/builtins/iterable/mod.rs
+++ b/core/engine/src/builtins/iterable/mod.rs
@@ -552,7 +552,7 @@ impl IteratorRecord {
     ///  - [ECMA reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-iteratorstepvalue
-    pub(crate) fn step_value(&mut self, context: &mut Context) -> JsResult<Option<JsValue>> {
+    pub fn step_value(&mut self, context: &mut Context) -> JsResult<Option<JsValue>> {
         // 1. Let result be ? IteratorStep(iteratorRecord).
         if self.step(context)? {
             // 2. If result is done, then
@@ -600,11 +600,7 @@ impl IteratorRecord {
     ///  - [ECMA reference][spec]
     ///
     ///  [spec]: https://tc39.es/ecma262/#sec-iteratorclose
-    pub(crate) fn close(
-        &self,
-        completion: JsResult<JsValue>,
-        context: &mut Context,
-    ) -> JsResult<JsValue> {
+    pub fn close(&self, completion: JsResult<JsValue>, context: &mut Context) -> JsResult<JsValue> {
         // 1. Assert: Type(iteratorRecord.[[Iterator]]) is Object.
 
         // 2. Let iterator be iteratorRecord.[[Iterator]].
diff --git a/core/engine/src/object/operations.rs b/core/engine/src/object/operations.rs
index 9ddb438070a..ccccdb8ec8f 100644
--- a/core/engine/src/object/operations.rs
+++ b/core/engine/src/object/operations.rs
@@ -794,7 +794,7 @@ impl JsObject {
     /// - [ECMAScript reference][spec]
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-getmethod
-    pub(crate) fn get_method<K>(&self, key: K, context: &mut Context) -> JsResult<Option<Self>>
+    pub fn get_method<K>(&self, key: K, context: &mut Context) -> JsResult<Option<Self>>
     where
         K: Into<PropertyKey>,
     {
diff --git a/core/runtime/src/url.rs b/core/runtime/src/url.rs
index e34b555987e..f39de1bd2c8 100644
--- a/core/runtime/src/url.rs
+++ b/core/runtime/src/url.rs
@@ -7,6 +7,10 @@
 //!  - [MDN documentation][mdn]
 //!  - [WHATWG `URL` specification][spec]
 //!
+//! Implemented sections in this file:
+//! - `URL.searchParams`: <https://url.spec.whatwg.org/#dom-url-searchparams>
+//! - `URLSearchParams` constructor and methods: <https://url.spec.whatwg.org/#urlsearchparams>
+//!
 //! [spec]: https://url.spec.whatwg.org/
 //! [mdn]: https://developer.mozilla.org/en-US/docs/Web/API/URL
 #![allow(clippy::needless_pass_by_value)]
@@ -14,18 +18,641 @@
 #[cfg(test)]
 mod tests;
 
+use boa_engine::builtins::iterable::{IteratorRecord, create_iter_result_object};
+use boa_engine::builtins::object::OrdinaryObject;
 use boa_engine::class::Class;
+use boa_engine::interop::{JsClass, TryFromJsArgument};
+use boa_engine::object::{
+    ObjectInitializer, WeakJsObject,
+    builtins::{JsArray, TypedJsFunction},
+};
+use boa_engine::property::Attribute;
 use boa_engine::realm::Realm;
 use boa_engine::value::Convert;
 use boa_engine::{
-    Context, Finalize, JsData, JsResult, JsString, JsValue, Trace, boa_class, boa_module, js_error,
+    Context, Finalize, JsData, JsError, JsObject, JsResult, JsString, JsSymbol, JsValue, Trace,
+    boa_class, boa_module, js_error, js_string, native_function::NativeFunction,
 };
+use std::collections::HashMap;
 use std::fmt::Display;
+use std::sync::{Arc, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
+
+/// A callback function for the `URLSearchParams.prototype.forEach` method.
+pub type SearchParamsForEachCallback = TypedJsFunction<(JsString, JsString, JsObject), ()>;
+
+#[derive(Debug, Clone, Copy)]
+enum UrlSearchParamsIteratorKind {
+    Key,
+    Value,
+    KeyAndValue,
+}
+
+fn to_usv_string(string: &JsString) -> JsString {
+    JsString::from(string.to_std_string_lossy())
+}
+
+fn to_usv_string_value(value: &JsValue, context: &mut Context) -> JsResult<JsString> {
+    value
+        .to_string(context)
+        .map(|string| to_usv_string(&string))
+}
+
+fn parse_search_params(input: &JsString) -> Vec<(JsString, JsString)> {
+    let input = input.to_std_string_lossy();
+    let input = input.strip_prefix('?').unwrap_or(&input);
+
+    url::form_urlencoded::parse(input.as_bytes())
+        .map(|(name, value)| {
+            (
+                JsString::from(name.as_ref()),
+                JsString::from(value.as_ref()),
+            )
+        })
+        .collect()
+}
+
+fn serialize_search_params(params: &[(JsString, JsString)]) -> String {
+    let mut serializer = url::form_urlencoded::Serializer::new(String::new());
+
+    for (name, value) in params {
+        let name = name.to_std_string_lossy();
+        let value = value.to_std_string_lossy();
+        serializer.append_pair(&name, &value);
+    }
+
+    serializer.finish()
+}
+
+#[derive(Debug, Clone)]
+struct SharedUrl(Arc<RwLock<url::Url>>);
+
+impl SharedUrl {
+    fn new(url: url::Url) -> Self {
+        Self(Arc::new(RwLock::new(url)))
+    }
+
+    fn read(&self) -> RwLockReadGuard<'_, url::Url> {
+        self.0.read().unwrap_or_else(PoisonError::into_inner)
+    }
+
+    fn write(&self) -> RwLockWriteGuard<'_, url::Url> {
+        self.0.write().unwrap_or_else(PoisonError::into_inner)
+    }
+
+    fn key(&self) -> usize {
+        Arc::as_ptr(&self.0) as usize
+    }
+
+    fn into_url(self) -> url::Url {
+        match Arc::try_unwrap(self.0) {
+            Ok(url) => url.into_inner().unwrap_or_else(PoisonError::into_inner),
+            Err(url) => url.read().unwrap_or_else(PoisonError::into_inner).clone(),
+        }
+    }
+}
+
+#[derive(Debug, Trace, Finalize, JsData)]
+struct UrlSearchParamsCacheEntry {
+    owner: WeakJsObject<Url>,
+    search_params: JsObject<UrlSearchParams>,
+}
+
+#[derive(Debug, Trace, Finalize, JsData)]
+struct UrlSearchParamsCache {
+    entries: HashMap<usize, UrlSearchParamsCacheEntry>,
+    next_sweep: usize,
+}
+
+impl Default for UrlSearchParamsCache {
+    fn default() -> Self {
+        Self {
+            entries: HashMap::new(),
+            next_sweep: 64,
+        }
+    }
+}
+
+impl UrlSearchParamsCache {
+    fn get(&self, key: usize) -> Option<JsObject<UrlSearchParams>> {
+        self.entries
+            .get(&key)
+            .map(|entry| entry.search_params.clone())
+    }
+
+    fn insert(
+        &mut self,
+        key: usize,
+        owner: &JsObject<Url>,
+        search_params: JsObject<UrlSearchParams>,
+    ) {
+        if self.entries.len() >= self.next_sweep {
+            self.entries.retain(|_, entry| entry.owner.is_upgradable());
+            self.next_sweep = self.entries.len().saturating_mul(2).max(64);
+        }
+
+        self.entries.insert(
+            key,
+            UrlSearchParamsCacheEntry {
+                owner: WeakJsObject::new(owner),
+                search_params,
+            },
+        );
+    }
+}
+
+/// Captures whether an optional argument was actually supplied.
+///
+/// This is used for overloads where an explicit `undefined` must not be treated
+/// the same as an omitted argument.
+#[derive(Debug, Clone)]
+struct OptionalArg(Option<JsValue>);
+
+impl<'a> TryFromJsArgument<'a> for OptionalArg {
+    fn try_from_js_argument(
+        _: &'a JsValue,
+        rest: &'a [JsValue],
+        _: &mut Context,
+    ) -> JsResult<(Self, &'a [JsValue])> {
+        match rest.split_first() {
+            Some((first, rest)) => Ok((Self(Some(first.clone())), rest)),
+            None => Ok((Self(None), rest)),
+        }
+    }
+}
+
+fn close_iterator_with_error<T>(
+    iterator: &IteratorRecord,
+    error: JsError,
+    context: &mut Context,
+) -> JsResult<T> {
+    match iterator.close(Err(error), context) {
+        Ok(_) => unreachable!("iterator close with error completion should not succeed"),
+        Err(err) => Err(err),
+    }
+}
+
+fn collect_sequence_item_pair(
+    item: &JsObject,
+    context: &mut Context,
+) -> JsResult<(JsString, JsString)> {
+    let Some(iterator_method) = item.get_method(JsSymbol::iterator(), context)? else {
+        return Err(js_error!(
+            TypeError: "URLSearchParams constructor expects each sequence item to be an iterable pair"
+        ));
+    };
+
+    let item_value = JsValue::from(item.clone());
+    let mut pair_iterator = item_value.get_iterator_from_method(&iterator_method, context)?;
+
+    let Some(name) = pair_iterator.step_value(context)? else {
+        return Err(js_error!(
+            TypeError: "URLSearchParams constructor expects each sequence item to contain exactly two values"
+        ));
+    };
+    let name = match to_usv_string_value(&name, context) {
+        Ok(name) => name,
+        Err(err) => return close_iterator_with_error(&pair_iterator, err, context),
+    };
+
+    let Some(value) = pair_iterator.step_value(context)? else {
+        return Err(js_error!(
+            TypeError: "URLSearchParams constructor expects each sequence item to contain exactly two values"
+        ));
+    };
+    let value = match to_usv_string_value(&value, context) {
+        Ok(value) => value,
+        Err(err) => return close_iterator_with_error(&pair_iterator, err, context),
+    };
+
+    if pair_iterator.step_value(context)?.is_some() {
+        return close_iterator_with_error(
+            &pair_iterator,
+            js_error!(
+                TypeError: "URLSearchParams constructor expects each sequence item to contain exactly two values"
+            ),
+            context,
+        );
+    }
+
+    Ok((name, value))
+}
+
+fn collect_sequence_pairs(
+    init: &JsValue,
+    iterator_method: &JsObject,
+    context: &mut Context,
+) -> JsResult<Vec<(JsString, JsString)>> {
+    let mut items = init.get_iterator_from_method(iterator_method, context)?;
+    let mut pairs = Vec::new();
+
+    while let Some(item) = items.step_value(context)? {
+        let Some(item_object) = item.as_object() else {
+            return close_iterator_with_error(
+                &items,
+                js_error!(
+                    TypeError: "URLSearchParams constructor expects each sequence item to be an iterable pair"
+                ),
+                context,
+            );
+        };
+
+        let pair = match collect_sequence_item_pair(&item_object, context) {
+            Ok(pair) => pair,
+            Err(err) => return close_iterator_with_error(&items, err, context),
+        };
+        pairs.push(pair);
+    }
+
+    Ok(pairs)
+}
+
+fn collect_record_pairs(
+    object: &JsObject,
+    context: &mut Context,
+) -> JsResult<Vec<(JsString, JsString)>> {
+    let keys = object.own_property_keys(context)?;
+    let mut pairs = Vec::new();
+
+    for key in keys {
+        let enumerable = OrdinaryObject::property_is_enumerable(
+            &object.clone().into(),
+            &[key.clone().into()],
+            context,
+        )?
+        .to_boolean();
+
+        if !enumerable {
+            continue;
+        }
+
+        let name = to_usv_string_value(&JsValue::from(key.clone()), context)?;
+        let value = to_usv_string_value(&object.get(key, context)?, context)?;
+        pairs.push((name, value));
+    }
+
+    Ok(pairs)
+}
+
+/// The `URLSearchParams` class represents the query portion of a URL.
+#[derive(Debug, JsData, Trace, Finalize)]
+pub struct UrlSearchParams {
+    list: Vec<(JsString, JsString)>,
+    #[unsafe_ignore_trace]
+    url: Option<SharedUrl>,
+}
+
+impl UrlSearchParams {
+    fn from_url(url: SharedUrl, context: &mut Context) -> JsResult<JsObject<Self>> {
+        Self::from_data(
+            Self {
+                list: Vec::new(),
+                url: Some(url),
+            },
+            context,
+        )?
+        .downcast::<Self>()
+        .map_err(|_| js_error!(Error: "URLSearchParams class should be registered"))
+    }
+
+    fn pairs(&self) -> Vec<(JsString, JsString)> {
+        if let Some(url) = &self.url {
+            let url = url.read();
+            return url
+                .query_pairs()
+                .map(|(name, value)| {
+                    (
+                        JsString::from(name.as_ref()),
+                        JsString::from(value.as_ref()),
+                    )
+                })
+                .collect();
+        }
+
+        self.list.clone()
+    }
+
+    fn update(&mut self, pairs: Vec<(JsString, JsString)>) {
+        if let Some(url) = &self.url {
+            let mut url = url.write();
+
+            if pairs.is_empty() {
+                url.set_query(None);
+            } else {
+                let query = serialize_search_params(&pairs);
+                url.set_query(Some(&query));
+            }
+            return;
+        }
+
+        self.list = pairs;
+    }
+}
+
+#[derive(Debug, JsData, Trace, Finalize)]
+struct UrlSearchParamsIterator {
+    search_params: JsObject<UrlSearchParams>,
+    next_index: usize,
+    #[unsafe_ignore_trace]
+    kind: UrlSearchParamsIteratorKind,
+    done: bool,
+}
+
+impl UrlSearchParamsIterator {
+    fn create(
+        search_params: JsObject<UrlSearchParams>,
+        kind: UrlSearchParamsIteratorKind,
+        context: &mut Context,
+    ) -> JsValue {
+        ObjectInitializer::with_native_data_and_proto(
+            Self {
+                search_params,
+                next_index: 0,
+                kind,
+                done: false,
+            },
+            context.intrinsics().constructors().iterator().prototype(),
+            context,
+        )
+        .function(
+            NativeFunction::from_fn_ptr(Self::next),
+            js_string!("next"),
+            0,
+        )
+        .function(
+            NativeFunction::from_fn_ptr(Self::iterator),
+            JsSymbol::iterator(),
+            0,
+        )
+        .property(
+            JsSymbol::to_string_tag(),
+            js_string!("URLSearchParams Iterator"),
+            Attribute::CONFIGURABLE,
+        )
+        .build()
+        .into()
+    }
+
+    #[allow(clippy::unnecessary_wraps)]
+    fn iterator(this: &JsValue, _: &[JsValue], _: &mut Context) -> JsResult<JsValue> {
+        Ok(this.clone())
+    }
+
+    fn next(this: &JsValue, _: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
+        let object = this
+            .as_object()
+            .ok_or_else(|| js_error!(TypeError: "`this` is not a URLSearchParams iterator"))?;
+        let mut iterator = object
+            .downcast_mut::<Self>()
+            .ok_or_else(|| js_error!(TypeError: "`this` is not a URLSearchParams iterator"))?;
+
+        if iterator.done {
+            return Ok(create_iter_result_object(
+                JsValue::undefined(),
+                true,
+                context,
+            ));
+        }
+
+        let pair = iterator
+            .search_params
+            .borrow()
+            .data()
+            .pairs()
+            .get(iterator.next_index)
+            .cloned();
+
+        let Some((name, value)) = pair else {
+            iterator.done = true;
+            return Ok(create_iter_result_object(
+                JsValue::undefined(),
+                true,
+                context,
+            ));
+        };
+
+        iterator.next_index += 1;
+
+        let result: JsValue = match iterator.kind {
+            UrlSearchParamsIteratorKind::Key => name.into(),
+            UrlSearchParamsIteratorKind::Value => value.into(),
+            UrlSearchParamsIteratorKind::KeyAndValue => {
+                JsArray::from_iter([name.into(), value.into()], context).into()
+            }
+        };
+
+        Ok(create_iter_result_object(result, false, context))
+    }
+}
+
+#[boa_class(rename = "URLSearchParams")]
+#[boa(rename_all = "camelCase")]
+impl UrlSearchParams {
+    /// WHATWG URL: <https://url.spec.whatwg.org/#dom-urlsearchparams-urlsearchparams>
+    ///
+    /// This implements the constructor branches for:
+    /// - empty / null init
+    /// - sequence input via @@iterator
+    /// - record input via enumerable own properties
+    /// - string input parsed as application/x-www-form-urlencoded
+    #[boa(constructor)]
+    fn constructor(init: JsValue, context: &mut Context) -> JsResult<Self> {
+        let list = if init.is_undefined() || init.is_null() {
+            Vec::new()
+        } else if let Some(object) = init.as_object() {
+            if let Some(iterator_method) = object.get_method(JsSymbol::iterator(), context)? {
+                collect_sequence_pairs(&init, &iterator_method, context)?
+            } else {
+                collect_record_pairs(&object, context)?
+            }
+        } else {
+            parse_search_params(&to_usv_string_value(&init, context)?)
+        };
+
+        Ok(Self { list, url: None })
+    }
+
+    #[boa(getter)]
+    fn size(&self) -> usize {
+        self.pairs().len()
+    }
+
+    fn append(&mut self, name: Convert<JsString>, value: Convert<JsString>) {
+        let mut pairs = self.pairs();
+        pairs.push((to_usv_string(&name.0), to_usv_string(&value.0)));
+        self.update(pairs);
+    }
+
+    fn delete(
+        &mut self,
+        name: Convert<JsString>,
+        value: OptionalArg,
+        context: &mut Context,
+    ) -> JsResult<()> {
+        // WHATWG URL: <https://url.spec.whatwg.org/#dom-urlsearchparams-delete>
+        // The second argument only participates when it was actually supplied.
+        let name = to_usv_string(&name.0);
+        let value = value
+            .0
+            .as_ref()
+            .map(|value| value.try_js_into::<Convert<JsString>>(context))
+            .transpose()?
+            .map(|value| to_usv_string(&value.0));
+        let mut pairs = self.pairs();
+
+        match value {
+            Some(value) => {
+                pairs.retain(|(existing_name, existing_value)| {
+                    existing_name != &name || existing_value != &value
+                });
+            }
+            None => {
+                pairs.retain(|(existing_name, _)| existing_name != &name);
+            }
+        }
+
+        self.update(pairs);
+        Ok(())
+    }
+
+    fn entries(this: JsClass<Self>, context: &mut Context) -> JsValue {
+        UrlSearchParamsIterator::create(
+            this.inner(),
+            UrlSearchParamsIteratorKind::KeyAndValue,
+            context,
+        )
+    }
+
+    #[boa(method)]
+    fn for_each(
+        this: JsClass<Self>,
+        callback: SearchParamsForEachCallback,
+        this_arg: Option<JsValue>,
+        context: &mut Context,
+    ) -> JsResult<()> {
+        let object = this.inner().upcast();
+        let this_arg = this_arg.unwrap_or_default();
+        let mut index = 0usize;
+
+        loop {
+            let pair = {
+                let params = this.borrow();
+                params.pairs().get(index).cloned()
+            };
+            let Some((name, value)) = pair else {
+                break;
+            };
+
+            callback.call_with_this(&this_arg, context, (value, name, object.clone()))?;
+            index += 1;
+        }
+
+        Ok(())
+    }
+
+    fn get(&self, name: Convert<JsString>) -> JsValue {
+        let name = to_usv_string(&name.0);
+        self.pairs()
+            .into_iter()
+            .find_map(|(existing_name, value)| (existing_name == name).then_some(value.into()))
+            .unwrap_or_else(JsValue::null)
+    }
+
+    fn get_all(&self, name: Convert<JsString>) -> Vec<JsString> {
+        let name = to_usv_string(&name.0);
+        self.pairs()
+            .into_iter()
+            .filter_map(|(existing_name, value)| (existing_name == name).then_some(value))
+            .collect()
+    }
+
+    fn has(
+        &self,
+        name: Convert<JsString>,
+        value: OptionalArg,
+        context: &mut Context,
+    ) -> JsResult<bool> {
+        // WHATWG URL: <https://url.spec.whatwg.org/#dom-urlsearchparams-has>
+        // The second argument only participates when it was actually supplied.
+        let name = to_usv_string(&name.0);
+        let value = value
+            .0
+            .as_ref()
+            .map(|value| value.try_js_into::<Convert<JsString>>(context))
+            .transpose()?
+            .map(|value| to_usv_string(&value.0));
+
+        Ok(match value {
+            Some(value) => self
+                .pairs()
+                .into_iter()
+                .any(|(existing_name, existing_value)| {
+                    existing_name == name && existing_value == value
+                }),
+            None => self
+                .pairs()
+                .into_iter()
+                .any(|(existing_name, _)| existing_name == name),
+        })
+    }
+
+    #[boa(symbol = "iterator")]
+    fn iterator(this: JsClass<Self>, context: &mut Context) -> JsValue {
+        Self::entries(this, context)
+    }
+
+    fn keys(this: JsClass<Self>, context: &mut Context) -> JsValue {
+        UrlSearchParamsIterator::create(this.inner(), UrlSearchParamsIteratorKind::Key, context)
+    }
+
+    fn set(&mut self, name: Convert<JsString>, value: Convert<JsString>) {
+        let name = to_usv_string(&name.0);
+        let value = to_usv_string(&value.0);
+        let mut found = false;
+        let mut result = Vec::with_capacity(self.pairs().len() + 1);
+
+        for (existing_name, existing_value) in self.pairs() {
+            if existing_name == name {
+                if !found {
+                    result.push((existing_name, value.clone()));
+                    found = true;
+                }
+            } else {
+                result.push((existing_name, existing_value));
+            }
+        }
+
+        if !found {
+            result.push((name, value));
+        }
+
+        self.update(result);
+    }
+
+    fn sort(&mut self) {
+        let mut pairs = self.pairs();
+        pairs.sort_by(|(left, _), (right, _)| left.cmp(right));
+        self.update(pairs);
+    }
+
+    fn to_string(&self) -> JsString {
+        JsString::from(serialize_search_params(&self.pairs()))
+    }
+
+    fn values(this: JsClass<Self>, context: &mut Context) -> JsValue {
+        UrlSearchParamsIterator::create(this.inner(), UrlSearchParamsIteratorKind::Value, context)
+    }
+}
 
 /// The `URL` class represents a (properly parsed) Uniform Resource Locator.
-#[derive(Debug, Clone, JsData, Trace, Finalize)]
+#[derive(Debug, JsData, Trace, Finalize)]
 #[boa_gc(unsafe_no_drop)]
-pub struct Url(#[unsafe_ignore_trace] url::Url);
+pub struct Url(#[unsafe_ignore_trace] SharedUrl);
+
+impl Clone for Url {
+    fn clone(&self) -> Self {
+        Self(SharedUrl::new(self.0.read().clone()))
+    }
+}
 
 impl Url {
     /// Register the `URL` class into the realm. Pass `None` for the realm to
@@ -36,23 +663,52 @@ impl Url {
     pub fn register(realm: Option<Realm>, context: &mut Context) -> JsResult<()> {
         js_module::boa_register(realm, context)
     }
+
+    /// Create a native `Url` value from Rust code.
+    ///
+    /// # Errors
+    /// Returns an error if `url` cannot be parsed against the optional `base`.
+    pub fn new(Convert(ref url): Convert<String>, base: Option<Convert<String>>) -> JsResult<Self> {
+        Self::parse_url(url, base.as_ref().map(|base| base.0.as_str())).map(Self::from)
+    }
+
+    /// Create a JavaScript `URL` object from native `Url` data.
+    ///
+    /// # Errors
+    /// Returns an error if the object cannot be allocated.
+    pub fn from_data(data: Self, context: &mut Context) -> JsResult<JsObject> {
+        <Self as Class>::from_data(data, context)
+    }
+
+    fn parse_url(url: &str, base: Option<&str>) -> JsResult<url::Url> {
+        if let Some(base) = base {
+            let base_url = url::Url::parse(base)
+                .map_err(|e| js_error!(TypeError: "Failed to parse base URL: {}", e))?;
+
+            base_url
+                .join(url)
+                .map_err(|e| js_error!(TypeError: "Failed to parse URL: {}", e))
+        } else {
+            url::Url::parse(url).map_err(|e| js_error!(TypeError: "Failed to parse URL: {}", e))
+        }
+    }
 }
 
 impl Display for Url {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "{}", self.0)
+        write!(f, "{}", *self.0.read())
     }
 }
 
 impl From<url::Url> for Url {
     fn from(url: url::Url) -> Self {
-        Self(url)
+        Self(SharedUrl::new(url))
     }
 }
 
 impl From<Url> for url::Url {
-    fn from(url: Url) -> url::Url {
-        url.0
+    fn from(url: Url) -> Self {
+        url.0.into_url()
     }
 }
 
@@ -64,153 +720,164 @@ impl Url {
     /// # Errors
     /// Any errors that might occur during URL parsing.
     #[boa(constructor)]
-    pub fn new(Convert(ref url): Convert<String>, base: Option<Convert<String>>) -> JsResult<Self> {
-        if let Some(Convert(ref base)) = base {
-            let base_url = url::Url::parse(base)
-                .map_err(|e| js_error!(TypeError: "Failed to parse base URL: {}", e))?;
-            if base_url.cannot_be_a_base() {
-                return Err(js_error!(TypeError: "Base URL {} cannot be a base", base));
-            }
-
-            let url = base_url
-                .join(url)
-                .map_err(|e| js_error!(TypeError: "Failed to parse URL: {}", e))?;
-            Ok(Self(url))
-        } else {
-            let url = url::Url::parse(url)
-                .map_err(|e| js_error!(TypeError: "Failed to parse URL: {}", e))?;
-            Ok(Self(url))
-        }
+    pub fn constructor(
+        Convert(ref url): Convert<String>,
+        base: Option<Convert<String>>,
+    ) -> JsResult<Self> {
+        Self::parse_url(url, base.as_ref().map(|base| base.0.as_str())).map(Self::from)
     }
 
     #[boa(getter)]
     fn hash(&self) -> JsString {
-        JsString::from(url::quirks::hash(&self.0))
+        JsString::from(url::quirks::hash(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "hash")]
     fn set_hash(&mut self, value: Convert<String>) {
-        url::quirks::set_hash(&mut self.0, &value.0);
+        url::quirks::set_hash(&mut self.0.write(), &value.0);
     }
 
     #[boa(getter)]
     fn hostname(&self) -> JsString {
-        JsString::from(url::quirks::hostname(&self.0))
+        JsString::from(url::quirks::hostname(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "hostname")]
     fn set_hostname(&mut self, value: Convert<String>) {
-        let _ = url::quirks::set_hostname(&mut self.0, &value.0);
+        let _ = url::quirks::set_hostname(&mut self.0.write(), &value.0);
     }
 
     #[boa(getter)]
     fn host(&self) -> JsString {
-        JsString::from(url::quirks::host(&self.0))
+        JsString::from(url::quirks::host(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "host")]
     fn set_host(&mut self, value: Convert<String>) {
-        let _ = url::quirks::set_host(&mut self.0, &value.0);
+        let _ = url::quirks::set_host(&mut self.0.write(), &value.0);
     }
 
     #[boa(getter)]
     fn href(&self) -> JsString {
-        JsString::from(url::quirks::href(&self.0))
+        JsString::from(url::quirks::href(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "href")]
     fn set_href(&mut self, value: Convert<String>) -> JsResult<()> {
-        url::quirks::set_href(&mut self.0, &value.0)
+        url::quirks::set_href(&mut self.0.write(), &value.0)
             .map_err(|e| js_error!(TypeError: "Failed to set href: {}", e))
     }
 
     #[boa(getter)]
     fn origin(&self) -> JsString {
-        JsString::from(url::quirks::origin(&self.0))
+        JsString::from(url::quirks::origin(&self.0.read()))
     }
 
     #[boa(getter)]
     fn password(&self) -> JsString {
-        JsString::from(url::quirks::password(&self.0))
+        JsString::from(url::quirks::password(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "password")]
     fn set_password(&mut self, value: Convert<String>) {
-        let _ = url::quirks::set_password(&mut self.0, &value.0);
+        let _ = url::quirks::set_password(&mut self.0.write(), &value.0);
     }
 
     #[boa(getter)]
     fn pathname(&self) -> JsString {
-        JsString::from(url::quirks::pathname(&self.0))
+        JsString::from(url::quirks::pathname(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "pathname")]
     fn set_pathname(&mut self, value: Convert<String>) {
-        let () = url::quirks::set_pathname(&mut self.0, &value.0);
+        let () = url::quirks::set_pathname(&mut self.0.write(), &value.0);
     }
 
     #[boa(getter)]
     fn port(&self) -> JsString {
-        JsString::from(url::quirks::port(&self.0))
+        JsString::from(url::quirks::port(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "port")]
     fn set_port(&mut self, value: Convert<JsString>) {
-        let _ = url::quirks::set_port(&mut self.0, &value.0.to_std_string_lossy());
+        let _ = url::quirks::set_port(&mut self.0.write(), &value.0.to_std_string_lossy());
     }
 
     #[boa(getter)]
     fn protocol(&self) -> JsString {
-        JsString::from(url::quirks::protocol(&self.0))
+        JsString::from(url::quirks::protocol(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "protocol")]
     fn set_protocol(&mut self, value: Convert<String>) {
-        let _ = url::quirks::set_protocol(&mut self.0, &value.0);
+        let _ = url::quirks::set_protocol(&mut self.0.write(), &value.0);
     }
 
     #[boa(getter)]
     fn search(&self) -> JsString {
-        JsString::from(url::quirks::search(&self.0))
+        JsString::from(url::quirks::search(&self.0.read()))
     }
 
     #[boa(setter)]
     #[boa(rename = "search")]
     fn set_search(&mut self, value: Convert<String>) {
-        url::quirks::set_search(&mut self.0, &value.0);
+        url::quirks::set_search(&mut self.0.write(), &value.0);
     }
 
     #[boa(getter)]
-    fn search_params() -> JsResult<()> {
-        Err(js_error!(Error: "URL.searchParams is not implemented"))
+    fn search_params(this: JsClass<Self>, context: &mut Context) -> JsResult<JsObject> {
+        let (key, url) = {
+            let url = this.borrow();
+            (url.0.key(), url.0.clone())
+        };
+
+        if let Some(search_params) = context
+            .get_data::<UrlSearchParamsCache>()
+            .and_then(|cache| cache.get(key))
+        {
+            return Ok(search_params.upcast());
+        }
+
+        let search_params = UrlSearchParams::from_url(url, context)?;
+        let owner = this.inner();
+
+        if let Some(cache) = context.host_defined_mut().get_mut::<UrlSearchParamsCache>() {
+            cache.insert(key, &owner, search_params.clone());
+        } else {
+            let mut cache = UrlSearchParamsCache::default();
+            cache.insert(key, &owner, search_params.clone());
+            context.insert_data(cache);
+        }
+
+        Ok(search_params.upcast())
     }
 
     #[boa(getter)]
     fn username(&self) -> JsString {
-        JsString::from(self.0.username())
+        JsString::from(self.0.read().username())
     }
 
     #[boa(setter)]
     #[boa(rename = "username")]
     fn set_username(&mut self, value: Convert<String>) {
-        let _ = self.0.set_username(&value.0);
+        let _ = self.0.write().set_username(&value.0);
     }
 
     fn to_string(&self) -> JsString {
-        JsString::from(format!("{}", self.0))
+        JsString::from(self.0.read().as_str())
     }
 
     #[boa(rename = "toJSON")]
     fn to_json(&self) -> JsString {
-        JsString::from(format!("{}", self.0))
+        JsString::from(self.0.read().as_str())
     }
 
     #[boa(static)]
@@ -220,7 +887,7 @@ impl Url {
 
     #[boa(static)]
     fn can_parse(url: Convert<String>, base: Option<Convert<String>>) -> bool {
-        Url::new(url, base).is_ok()
+        Self::parse_url(&url.0, base.as_ref().map(|base| base.0.as_str())).is_ok()
     }
 
     #[boa(static)]
@@ -229,9 +896,10 @@ impl Url {
         base: Option<Convert<String>>,
         context: &mut Context,
     ) -> JsResult<JsValue> {
-        Url::new(url, base).map_or(Ok(JsValue::null()), |u| {
-            Url::from_data(u, context).map(JsValue::from)
-        })
+        Self::parse_url(&url.0, base.as_ref().map(|base| base.0.as_str()))
+            .map_or(Ok(JsValue::null()), |url| {
+                Self::from_data(Self::from(url), context).map(JsValue::from)
+            })
     }
 
     #[boa(static)]
@@ -244,4 +912,5 @@ impl Url {
 #[boa_module]
 pub mod js_module {
     type Url = super::Url;
+    type UrlSearchParams = super::UrlSearchParams;
 }
diff --git a/core/runtime/src/url/tests.rs b/core/runtime/src/url/tests.rs
index 21cfc836955..6a8cc581d4e 100644
--- a/core/runtime/src/url/tests.rs
+++ b/core/runtime/src/url/tests.rs
@@ -1,4 +1,7 @@
+use super::Url;
 use crate::test::{TestAction, run_test_actions};
+use boa_engine::value::Convert;
+use std::panic::{RefUnwindSafe, UnwindSafe};
 
 const TEST_HARNESS: &str = r#"
 function assert(condition, message) {
@@ -17,6 +20,26 @@ function assert_eq(a, b, message) {
 }
 "#;
 
+#[test]
+fn url_preserves_public_traits() {
+    fn assert_traits<T: Clone + Send + Sync + UnwindSafe + RefUnwindSafe>() {}
+
+    assert_traits::<Url>();
+}
+
+#[test]
+fn url_clone_has_independent_state() {
+    let original = Url::from(url::Url::parse("https://example.com/?a=1").unwrap());
+    let mut cloned = original.clone();
+
+    cloned.set_search(Convert("?b=2".to_owned()));
+
+    let original: url::Url = original.into();
+    let cloned: url::Url = cloned.into();
+    assert_eq!(original.query(), Some("a=1"));
+    assert_eq!(cloned.query(), Some("b=2"));
+}
+
 #[test]
 fn url_basic() {
     run_test_actions([
@@ -68,6 +91,12 @@ fn url_base() {
                 assert_eq(url.hash, "#fragment");
             "##,
         ),
+        TestAction::run(
+            r##"
+                url = new URL("http://example.org/new/path?new-query#new-fragment", "about:blank");
+                assert_eq(url.href, "http://example.org/new/path?new-query#new-fragment");
+            "##,
+        ),
     ]);
 }
 
@@ -107,6 +136,474 @@ fn url_static_methods() {
                 assert(!URL.canParse("http//:example.org/new/path?new-query#new-fragment"));
                 assert(!URL.canParse("http://example.org/new/path?new-query#new-fragment", "http:"));
                 assert(URL.canParse("/new/path?new-query#new-fragment", "http://example.org/"));
+                assert(URL.canParse("http://example.org/new/path?new-query#new-fragment", "about:blank"));
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const parsed = URL.parse("https://example.org/?a=1");
+                assert(parsed instanceof URL);
+                assert_eq(parsed.searchParams.get("a"), "1");
+
+                parsed.searchParams.append("b", "2");
+                assert_eq(parsed.href, "https://example.org/?a=1&b=2");
+                assert_eq(URL.parse("http//:example.org/"), null);
+            "##,
+        ),
+    ]);
+}
+
+#[test]
+fn url_search_params_constructor_and_methods() {
+    run_test_actions([
+        TestAction::run(TEST_HARNESS),
+        TestAction::run(
+            r##"
+                const params = new URLSearchParams([["b", "2"], ["a", "1"], ["a", "3"]]);
+                assert_eq(params.size, 3);
+                assert_eq(params.get("a"), "1");
+                assert_eq(params.get("missing"), null);
+                assert_eq(params.getAll("a").join(","), "1,3");
+                assert(params.has("b"));
+                assert(!params.has("b", "4"));
+
+                params.append("c", "5");
+                params.delete("a", "1");
+                params.set("b", "4");
+                params.sort();
+
+                assert_eq(params.toString(), "a=3&b=4&c=5");
+                assert_eq([...params].map(([k, v]) => `${k}=${v}`).join("&"), "a=3&b=4&c=5");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const fromObject = new URLSearchParams({ a: "1", b: "2" });
+                assert_eq(fromObject.toString(), "a=1&b=2");
+
+                const fromString = new URLSearchParams("?x=1&x=2");
+                assert_eq(fromString.getAll("x").join(","), "1,2");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const fromIterableObject = new URLSearchParams({
+                    *[Symbol.iterator]() {
+                        yield ["i", "1"];
+                        yield new Set(["j", "2"]);
+                    },
+                    ignored: "value",
+                });
+                assert_eq(fromIterableObject.toString(), "i=1&j=2");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const record = Object.create({ inherited: "x" });
+                Object.defineProperty(record, "hidden", { value: "2", enumerable: false });
+                record.a = "1";
+                assert_eq(new URLSearchParams(record).toString(), "a=1");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const originalFrom = Array.from;
+                Array.from = () => {
+                    throw new Error("patched");
+                };
+
+                try {
+                    const params = new URLSearchParams([["a", "1"], new Set(["b", "2"])]);
+                    assert_eq(params.toString(), "a=1&b=2");
+                } finally {
+                    Array.from = originalFrom;
+                }
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const customParams = new URLSearchParams("x=1");
+                customParams[Symbol.iterator] = function* () {
+                    yield ["a", "b"];
+                };
+
+                assert_eq(new URLSearchParams(customParams).toString(), "a=b");
+            "##,
+        ),
+    ]);
+}
+
+#[test]
+fn url_search_params_is_live_and_cached() {
+    run_test_actions([
+        TestAction::run(TEST_HARNESS),
+        TestAction::run(
+            r##"
+                const url = new URL("https://example.com/?a=1&b=2");
+                const params1 = url.searchParams;
+                const params2 = url.searchParams;
+
+                assert(params1 === params2, "searchParams must be the same object");
+                assert_eq(params1.get("a"), "1");
+
+                params1.append("c", "3");
+                assert_eq(url.search, "?a=1&b=2&c=3");
+
+                url.search = "?x=9";
+                assert_eq(params1.get("x"), "9");
+                assert_eq(params1.get("a"), null);
+
+                params1.delete("x");
+                assert_eq(url.href, "https://example.com/");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const liveUrl = new URL("http://a.b/c?a=1&b=2&c=3");
+                const liveSeen = [];
+
+                for (const entry of liveUrl.searchParams) {
+                    if (entry[0] === "a") {
+                        liveUrl.search = "x=1&y=2&z=3";
+                    }
+                    liveSeen.push(entry.join("="));
+                }
+
+                assert_eq(liveSeen.join("&"), "a=1&y=2&z=3");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const forEachUrl = new URL("http://localhost/query?param0=0&param1=1&param2=2");
+                const forEachSeen = [];
+
+                forEachUrl.searchParams.forEach((value, key) => {
+                    forEachSeen.push(`${key}=${value}`);
+                    if (key === "param0") {
+                        forEachUrl.searchParams.delete("param1");
+                    }
+                });
+
+                assert_eq(forEachSeen.join("&"), "param0=0&param2=2");
+            "##,
+        ),
+    ]);
+}
+
+#[test]
+fn url_search_params_iterators() {
+    run_test_actions([
+        TestAction::run(TEST_HARNESS),
+        TestAction::run(
+            r##"
+                const params = new URLSearchParams([["a", "1"], ["b", "2"]]);
+                const entries = params.entries();
+
+                assert(entries[Symbol.iterator]() === entries, "iterator should return itself");
+                assert_eq(Object.prototype.toString.call(entries), "[object URLSearchParams Iterator]");
+
+                assert_eq(entries.next().value.join("="), "a=1");
+                assert_eq(entries.next().value.join("="), "b=2");
+
+                const done = entries.next();
+                assert(done.done);
+                assert_eq(done.value, undefined);
+
+                const doneAgain = entries.next();
+                assert(doneAgain.done);
+                assert_eq(doneAgain.value, undefined);
+
+                assert_eq([...params.keys()].join(","), "a,b");
+                assert_eq([...params.values()].join(","), "1,2");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const next = new URLSearchParams("a=1").entries().next;
+
+                let primitiveThisThrew = false;
+                try {
+                    next.call(1);
+                } catch (e) {
+                    primitiveThisThrew = e instanceof TypeError;
+                }
+                assert(primitiveThisThrew, "calling iterator next with primitive this must throw");
+
+                let wrongObjectThrew = false;
+                try {
+                    next.call({});
+                } catch (e) {
+                    wrongObjectThrew = e instanceof TypeError;
+                }
+                assert(wrongObjectThrew, "calling iterator next with a plain object must throw");
+            "##,
+        ),
+    ]);
+}
+
+#[test]
+fn url_search_params_optional_value_argument() {
+    run_test_actions([
+        TestAction::run(TEST_HARNESS),
+        TestAction::run(
+            r##"
+                const params = new URLSearchParams("a=b&a=undefined&b=c");
+
+                assert(params.has("a", undefined));
+                assert(!params.has("a", "missing"));
+
+                params.delete("a", undefined);
+                assert_eq(params.toString(), "a=b&b=c");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const deleteAllParams = new URLSearchParams("a=b&a=undefined&a=d");
+                deleteAllParams.delete("a");
+                assert_eq(deleteAllParams.toString(), "");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const url = new URL("https://example.com/?a=undefined&a=x");
+                assert(url.searchParams.has("a", undefined));
+                url.searchParams.delete("a", undefined);
+                assert_eq(url.search, "?a=x");
+            "##,
+        ),
+    ]);
+}
+
+#[test]
+fn url_search_params_constructor_errors() {
+    run_test_actions([
+        TestAction::run(TEST_HARNESS),
+        TestAction::run(
+            r##"
+                assert_eq(new URLSearchParams().toString(), "");
+                assert_eq(new URLSearchParams(null).toString(), "");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                var threw = false;
+                try {
+                    new URLSearchParams(new String("ab"));
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+                assert(threw, "string wrapper objects must use the iterable branch");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                var threw = false;
+                try {
+                    new URLSearchParams([[1, 2, 3]]);
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+                assert(threw, "pairs with length != 2 must throw");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                var threw = false;
+                try {
+                    new URLSearchParams({ a: "1", [Symbol.iterator]: 1 });
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+                assert(threw, "non-callable @@iterator must throw");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                const key = Symbol("k");
+                var threw = false;
+                try {
+                    new URLSearchParams({ [key]: "1", a: "2" });
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+                assert(threw, "enumerable symbol keys must throw during record conversion");
+            "##,
+        ),
+    ]);
+}
+
+#[test]
+fn url_search_params_constructor_iterator_cleanup_errors() {
+    run_test_actions([
+        TestAction::run(TEST_HARNESS),
+        TestAction::run(
+            r##"
+                var cleanup = [];
+                var threw = false;
+
+                try {
+                    new URLSearchParams({
+                        [Symbol.iterator]() {
+                            return {
+                                next() {
+                                    return { value: 1, done: false };
+                                },
+                                return() {
+                                    cleanup.push("outer");
+                                    return {};
+                                },
+                            };
+                        },
+                    });
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+
+                assert(threw, "non-object sequence items must throw");
+                assert_eq(cleanup.join(","), "outer");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                var cleanup = [];
+                var threw = false;
+
+                try {
+                    new URLSearchParams({
+                        [Symbol.iterator]() {
+                            return {
+                                next() {
+                                    return {
+                                        value: {
+                                            [Symbol.iterator]() {
+                                                let step = 0;
+                                                return {
+                                                    next() {
+                                                        step += 1;
+                                                        if (step === 1) {
+                                                            return { value: "a", done: false };
+                                                        }
+                                                        if (step === 2) {
+                                                            return {
+                                                                value: {
+                                                                    toString() {
+                                                                        throw new Error("boom");
+                                                                    },
+                                                                },
+                                                                done: false,
+                                                            };
+                                                        }
+                                                        return { done: true };
+                                                    },
+                                                    return() {
+                                                        cleanup.push("pair");
+                                                        return {};
+                                                    },
+                                                };
+                                            },
+                                        },
+                                        done: false,
+                                    };
+                                },
+                                return() {
+                                    cleanup.push("outer");
+                                    return {};
+                                },
+                            };
+                        },
+                    });
+                } catch (e) {
+                    threw = e instanceof Error && e.message === "boom";
+                }
+
+                assert(threw, "errors from pair value coercion must propagate");
+                assert_eq(cleanup.join(","), "pair,outer");
+            "##,
+        ),
+    ]);
+}
+
+#[test]
+fn url_search_params_constructor_iterator_protocol_errors() {
+    run_test_actions([
+        TestAction::run(TEST_HARNESS),
+        TestAction::run(
+            r##"
+                var threw = false;
+
+                try {
+                    new URLSearchParams({
+                        [Symbol.iterator]() {
+                            return 1;
+                        },
+                    });
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+
+                assert(threw, "iterator methods must return an object");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                var threw = false;
+
+                try {
+                    new URLSearchParams({
+                        [Symbol.iterator]() {
+                            return { next: 1 };
+                        },
+                    });
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+
+                assert(threw, "iterator next must be callable");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                var threw = false;
+
+                try {
+                    new URLSearchParams({
+                        [Symbol.iterator]() {
+                            return {
+                                next() {
+                                    return 1;
+                                },
+                            };
+                        },
+                    });
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+
+                assert(threw, "iterator next result must be an object");
+            "##,
+        ),
+        TestAction::run(
+            r##"
+                var threw = false;
+
+                try {
+                    new URLSearchParams({
+                        [Symbol.iterator]() {
+                            return {
+                                next() {
+                                    return { value: 1, done: false };
+                                },
+                                return() {
+                                    return 1;
+                                },
+                            };
+                        },
+                    });
+                } catch (e) {
+                    threw = e instanceof TypeError;
+                }
+
+                assert(threw, "iterator return must produce an object");
             "##,
         ),
     ]);
diff --git a/tests/wpt/src/lib.rs b/tests/wpt/src/lib.rs
index ef538b61eee..653beb45235 100644
--- a/tests/wpt/src/lib.rs
+++ b/tests/wpt/src/lib.rs
@@ -1,7 +1,6 @@
 //! Integration tests running the Web Platform Tests (WPT) for the `boa_runtime` crate.
 #![allow(unused_crate_dependencies)]
 
-use boa_engine::class::Class;
 use boa_engine::interop::ContextData;
 use boa_engine::parser::source::UTF16Input;
 use boa_engine::property::Attribute;
@@ -411,8 +410,6 @@ fn url(
     #[base_dir = "${WPT_ROOT}"]
     #[files("url/url-*.any.js")]
     #[exclude("idlharness")]
-    // "Base URL about:blank cannot be a base"
-    #[exclude("url-searchparams.any.js")]
     // "fetch is not defined"
     #[exclude("url-origin.any.js")]
     #[exclude("url-setters.any.js")]