diff --git a/CHANGELOG.md b/CHANGELOG.md
index 5983ae29..7f47b8b8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Added
+
+- Added the `extra_index_urls` and `index_strategy` parameters to `micropip.install()`
+  to support lookup and installation from multiple package indexes.
+  [#224](https://github.com/pyodide/micropip/pull/224)
+
 ### Fixed
 
 - micropip now respects the `yanked` flag in the PyPI Simple API.
diff --git a/micropip/__init__.py b/micropip/__init__.py
index 255e7b25..2ec6671e 100644
--- a/micropip/__init__.py
+++ b/micropip/__init__.py
@@ -11,6 +11,7 @@
 
 install = _package_manager_singleton.install
 set_index_urls = _package_manager_singleton.set_index_urls
+set_extra_index_urls = _package_manager_singleton.set_extra_index_urls
 list = _package_manager_singleton.list_packages
 set_constraints = _package_manager_singleton.set_constraints
 freeze = _package_manager_singleton.freeze
diff --git a/micropip/package_index.py b/micropip/package_index.py
index 8128f06b..6ed1a6a4 100644
--- a/micropip/package_index.py
+++ b/micropip/package_index.py
@@ -268,10 +268,12 @@ def _select_parser(
             raise ValueError(f"Unsupported content type: {content_type}")
 
 
-async def query_package(
+# TODO: reduce mccabe complexity
+async def query_package(  # noqa: C901
     name: str,
     index_urls: list[str] | str,
     fetch_kwargs: dict[str, Any] | None = None,
+    strategy: str = "first-index",
 ) -> ProjectInfo:
     """
     Query for a package from package indexes.
@@ -286,6 +288,9 @@ async def query_package(
         it finds a package. If no package is found, an error will be raised.
     fetch_kwargs
         Keyword arguments to pass to the fetch function.
+    strategy
+        Index strategy to use when querying multiple indexes. The default is "first-index".
+        Valid values are: "first-index", "unsafe-first-match", and "unsafe-best-match".
     """
 
     _fetch_kwargs = fetch_kwargs.copy() if fetch_kwargs else {}
@@ -303,36 +308,101 @@ async def query_package(
 
     index_urls = [PYPI_URL if url == PYPI else url for url in index_urls]
 
-    for url in index_urls:
-        logger.debug("Looping through index urls: %r", url)
-        if _contain_placeholder(url):
-            url = url.format(package_name=name)
-            logger.debug("Formatting url with package name : %r", url)
-        else:
-            url = f"{url}/{name}/"
-            logger.debug("Url has no placeholder, appending package name : %r", url)
-        try:
-            metadata, headers = await fetch_string_and_headers(url, _fetch_kwargs)
-        except HttpStatusError as e:
-            if e.status_code == 404:
-                logger.debug("NotFound (404) for %r, trying next index.", url)
+    projects_info = []
+
+    # With "first-index" strategy, we'll return the first match we find
+    # without checking the other indexes at all.
+    if strategy == "first-index":
+        for url in index_urls:
+            logger.debug("Looping through index urls: %r", url)
+            if _contain_placeholder(url):
+                url = url.format(package_name=name)
+                logger.debug("Formatting url with package name : %r", url)
+            else:
+                url = f"{url}/{name}/"
+                logger.debug("Url has no placeholder, appending package name : %r", url)
+            try:
+                metadata, headers = await fetch_string_and_headers(url, _fetch_kwargs)
+            except HttpStatusError as e:
+                if e.status_code == 404:
+                    logger.debug("NotFound (404) for %r, trying next index.", url)
+                    continue
+                logger.debug(
+                    "Error fetching %r (%s), trying next index.", url, e.status_code
+                )
+                raise
+
+            content_type = headers.get("content-type", "").lower()
+            try:
+                base_url = urlunparse(urlparse(url)._replace(path=""))
+                parser = _select_parser(content_type, name, index_base_url=base_url)
+            except ValueError as e:
+                raise ValueError(f"Error trying to decode url: {url}") from e
+            return parser(metadata)
+    # With "unsafe-first-match" or "unsafe-best-match", we need to check all indexes
+    else:
+        for url in index_urls:
+            logger.debug("Looping through index urls: %r", url)
+            if _contain_placeholder(url):
+                url = url.format(package_name=name)
+                logger.debug("Formatting url with package name : %r", url)
+            else:
+                url = f"{url}/{name}/"
+                logger.debug("Url has no placeholder, appending package name : %r", url)
+            try:
+                metadata, headers = await fetch_string_and_headers(url, _fetch_kwargs)
+            except HttpStatusError as e:
+                if e.status_code == 404:
+                    logger.debug("NotFound (404) for %r, trying next index.", url)
+                    continue
+                logger.debug(
+                    "Error fetching %r (%s), trying next index.", url, e.status_code
+                )
+                continue  # try the next index instead of raising
+
+            content_type = headers.get("content-type", "").lower()
+            try:
+                base_url = urlunparse(urlparse(url)._replace(path=""))
+                parser = _select_parser(content_type, name, index_base_url=base_url)
+                projects_info.append(parser(metadata))
+            except ValueError:
+                # Just log and continue with the next index
+                msg = f"Error trying to decode url: {url}"
+                logger.debug(msg)
                 continue
-            logger.debug(
-                "Error fetching %r (%s), trying next index.", url, e.status_code
-            )
-            raise
 
-        content_type = headers.get("content-type", "").lower()
-        try:
-            base_url = urlunparse(urlparse(url)._replace(path=""))
+        if not projects_info:
+            raise ValueError(
+                f"Can't fetch metadata for '{name}'. "
+                "Please make sure you have entered a correct package name "
+                "and correctly specified index_urls (if you changed them)."
+            )
 
-            parser = _select_parser(content_type, name, index_base_url=base_url)
-        except ValueError as e:
-            raise ValueError(f"Error trying to decode url: {url}") from e
-        return parser(metadata)
-    else:
-        raise ValueError(
-            f"Can't fetch metadata for '{name}'. "
-            "Please make sure you have entered a correct package name "
-            "and correctly specified index_urls (if you changed them)."
-        )
+        # For "unsafe-first-match", return the first project that has matching versions
+        if strategy == "unsafe-first-match":
+            return projects_info[0]
+
+        # For "unsafe-best-match", we merge information from all indexes.
+        merged_project = projects_info[0]
+        for project in projects_info[1:]:
+            for version, wheels in project.releases.items():
+                if version not in merged_project.releases:
+                    merged_project.releases[version] = wheels
+                else:
+                    # Extend the existing wheels generator with new wheels
+                    # This is a bit tricky with generators, so we'll convert
+                    # to lists temporarily
+                    existing_wheels = list(merged_project.releases[version])
+                    new_wheels = list(wheels)
+                    merged_project.releases[version] = (
+                        wheel for wheel in existing_wheels + new_wheels
+                    )
+
+        return merged_project
+
+    # If we get here, we weren't find the package in any index
+    raise ValueError(
+        f"Can't fetch metadata for '{name}'. "
+        "Please make sure you have entered a correct package name "
+        "and correctly specified index_urls (if you changed them)."
+    )
diff --git a/micropip/package_manager.py b/micropip/package_manager.py
index 0ad6fda0..52dc6fd5 100644
--- a/micropip/package_manager.py
+++ b/micropip/package_manager.py
@@ -33,6 +33,8 @@ def __init__(self, compat: type[CompatibilityLayer] | None = None) -> None:
             compat = compatibility_layer
 
         self.index_urls = package_index.DEFAULT_INDEX_URLS[:]
+        self.extra_index_urls: list[str] = []
+        self.index_strategy = "first-index"  # default strategy
         self.compat_layer: type[CompatibilityLayer] = compat
         self.constraints: list[str] = []
 
@@ -47,6 +49,8 @@ async def install(
         pre: bool = False,
         index_urls: list[str] | str | None = None,
         *,
+        extra_index_urls: list[str] | str | None = None,
+        index_strategy: str | None = None,
         constraints: list[str] | None = None,
         verbose: bool | int | None = None,
     ) -> None:
@@ -132,6 +136,29 @@ async def install(
             - If a list of URLs is provided, micropip will try each URL in order until \
             it finds a package. If no package is found, an error will be raised.
 
+        extra_index_urls:
+
+            A list of URLs or a single URL to use as additional package indexes when looking
+            up packages. Unlike `index_urls`, these are used in addition to the default
+            indexes, not instead of them. This is useful for finding packages that may not
+            be available in the main package index that is queried by `index_urls`.
+
+            - The format and behaviour of each URL is the same as for `index_urls`.
+
+        index_strategy:
+
+            Determines how package versions are selected when they appear in multiple indexes:
+
+            - ``first-index`` (default): Search for each package across all indexes, limiting \
+            the candidate versions to those present in the first index that contains the package.
+
+            - ``unsafe-first-match``: Search for each package across all indexes, but prefer \
+            the first index with a compatible version, even if newer versions are available \
+            on other indexes.
+
+            - ``unsafe-best-match``: Search for each package across all indexes, and select \
+            the best version from the combined set of candidate versions (pip's default).
+
         constraints:
 
             A list of requirements with versions/URLs which will be used only if
@@ -149,6 +176,26 @@ async def install(
         with setup_logging().ctx_level(verbose) as logger:
             if index_urls is None:
                 index_urls = self.index_urls
+                base_index_urls = self.index_urls
+            else:
+                base_index_urls = (
+                    index_urls if isinstance(index_urls, list) else [index_urls]
+                )
+
+            if extra_index_urls is None:
+                extra_urls = self.extra_index_urls
+            else:
+                extra_urls = (
+                    extra_index_urls
+                    if isinstance(extra_index_urls, list)
+                    else [extra_index_urls]
+                )
+
+            combined_index_urls = base_index_urls + extra_urls
+
+            strategy = (
+                index_strategy if index_strategy is not None else self.index_strategy
+            )
 
             if constraints is None:
                 constraints = self.constraints
@@ -177,8 +224,9 @@ async def install(
                 pre=pre,
                 fetch_kwargs=fetch_kwargs,
                 verbose=verbose,
-                index_urls=index_urls,
+                index_urls=combined_index_urls,
                 constraints=constraints,
+                index_strategy=strategy,
             )
             await transaction.gather_requirements(requirements)
 
@@ -232,6 +280,60 @@ async def install(
 
             importlib.invalidate_caches()
 
+    def set_extra_index_urls(self, urls: List[str] | str):  # noqa: UP006
+        """
+        Set the extra index URLs to use when looking up packages.
+
+        These URLs are used in addition to the default index URLs, not instead of them.
+        This is useful for finding packages that may not be available in the main
+        package index.
+
+        - The index URL should support the \
+            `JSON API <https://warehouse.pypa.io/api-reference/json/>`__ .
+
+        - The index URL may contain the placeholder {package_name} which will be \
+            replaced with the package name when looking up a package. If it does not \
+            contain the placeholder, the package name will be appended to the URL.
+
+        Parameters
+        ----------
+        urls
+            A list of URLs or a single URL to use as extra package indexes.
+        """
+
+        if isinstance(urls, str):
+            urls = [urls]
+
+        self.extra_index_urls = urls[:]
+
+    def set_index_strategy(self, strategy: str):
+        """
+        Set the index strategy to use when resolving packages from multiple indexes.
+
+        Parameters
+        ----------
+        strategy
+            The index strategy to use. Valid values are:
+
+            - ``first-index``: Search for each package across all indexes, limiting \
+            the candidate versions to those present in the first index that contains the package.
+
+            - ``unsafe-first-match``: Search for each package across all indexes, but prefer \
+            the first index with a compatible version, even if newer versions are available \
+            on other indexes.
+
+            - ``unsafe-best-match``: Search for each package across all indexes, and select \
+            the best version from the combined set of candidate versions (pip's default).
+        """
+        valid_strategies = ["first-index", "unsafe-first-match", "unsafe-best-match"]
+        if strategy not in valid_strategies:
+            raise ValueError(
+                f"Invalid index strategy: {strategy}. "
+                f"Valid strategies are: {', '.join(valid_strategies)}"
+            )
+
+        self.index_strategy = strategy
+
     def list_packages(self) -> PackageDict:
         """Get the dictionary of installed packages.
 
diff --git a/micropip/transaction.py b/micropip/transaction.py
index db326654..999f6ce4 100644
--- a/micropip/transaction.py
+++ b/micropip/transaction.py
@@ -45,6 +45,7 @@ class Transaction:
 
     verbose: bool | int | None = None
     constraints: list[str] | None = None
+    index_strategy: str = "first-index"
 
     def __post_init__(self) -> None:
         # If index_urls is None, pyodide-lock.json have to be searched first.
@@ -231,11 +232,12 @@ async def _add_requirement_from_package_index(self, req: Requirement):
             req.name,
             self.index_urls,
             self.fetch_kwargs,
+            strategy=self.index_strategy,
         )
 
         logger.debug("Transaction: got metadata %r for requirement %r", metadata, req)
 
-        wheel = find_wheel(metadata, req)
+        wheel = find_wheel(metadata, req, self.index_strategy)
 
         logger.debug("Transaction: Selected wheel: %r", wheel)
 
@@ -319,12 +321,17 @@ async def add_wheel(
         self.wheels.append(wheel)
 
 
-def find_wheel(metadata: ProjectInfo, req: Requirement) -> WheelInfo:
+def find_wheel(
+    metadata: ProjectInfo, req: Requirement, strategy: str = "first-index"
+) -> WheelInfo:
     """Parse metadata to find the latest version of pure python wheel.
     Parameters
     ----------
     metadata : ProjectInfo
     req : Requirement
+    strategy : str, optional
+        The strategy to find the wheel when selecting package versions.
+        The default is "first-index".
 
     Returns
     -------
diff --git a/tests/conftest.py b/tests/conftest.py
index 02719a3f..53662e96 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -304,7 +304,9 @@ def add_pkg_version(
         self.metadata_map[filename] = metadata
         self.top_level_map[filename] = top_level
 
-    async def query_package(self, pkgname, index_urls, kwargs):
+    async def query_package(
+        self, pkgname, index_urls, extra_index_urls, strategy, **kwargs
+    ):
         from micropip.package_index import ProjectInfo
 
         try:
diff --git a/tests/test_package_manager.py b/tests/test_package_manager.py
index 37c670c3..8c947e5a 100644
--- a/tests/test_package_manager.py
+++ b/tests/test_package_manager.py
@@ -33,6 +33,26 @@ def test_set_index_urls():
         assert manager.index_urls == default_index_urls
 
 
+def test_set_extra_index_urls():
+    manager = get_test_package_manager()
+
+    # Initially, extra_index_urls should be empty
+    assert manager.extra_index_urls == []
+
+    valid_url1 = "https://pkg-index.com/{package_name}/json/"
+    valid_url2 = "https://another-pkg-index.com/{package_name}"
+    valid_url3 = "https://another-pkg-index.com/simple/"
+    try:
+        manager.set_extra_index_urls(valid_url1)
+        assert manager.extra_index_urls == [valid_url1]
+
+        manager.set_extra_index_urls([valid_url1, valid_url2, valid_url3])
+        assert manager.extra_index_urls == [valid_url1, valid_url2, valid_url3]
+    finally:
+        manager.set_extra_index_urls([])
+        assert manager.extra_index_urls == []
+
+
 @pytest.mark.asyncio
 async def test_list_packages(mock_fetch: mock_fetch_cls):
     manager = get_test_package_manager()
@@ -49,6 +69,25 @@ async def test_list_packages(mock_fetch: mock_fetch_cls):
     assert pkg_list[dummy].source.lower() == dummy_url
 
 
+def test_set_index_strategy():
+    manager = get_test_package_manager()
+
+    # Initially, index_strategy should be 'first-index'
+    assert manager.index_strategy == "first-index"
+
+    valid_strategies = ["first-index", "unsafe-first-match", "unsafe-best-match"]
+    try:
+        for strategy in valid_strategies:
+            manager.set_index_strategy(strategy)
+            assert manager.index_strategy == strategy
+
+        # Test invalid strategy
+        with pytest.raises(ValueError):
+            manager.set_index_strategy("invalid-strategy")
+    finally:
+        manager.set_index_strategy("first-index")
+
+
 @pytest.mark.asyncio
 async def test_custom_index_url(mock_package_index_json_api, monkeypatch):
     manager = get_test_package_manager()
@@ -78,3 +117,195 @@ async def _mock_fetch_bytes(url, *args):
         pass
 
     assert "fake_pkg_micropip_test-1.0.0-py2.py3-none-any.whl" in _wheel_url
+
+
+@pytest.mark.asyncio
+async def test_extra_index_urls_parameter(mock_package_index_json_api, monkeypatch):
+    manager = get_test_package_manager()
+
+    # Set up two mock servers with different packages
+    main_index_url = mock_package_index_json_api(
+        pkgs=["package-a"], pkgs_not_found=["package-b"]
+    )
+    extra_index_url = mock_package_index_json_api(
+        pkgs=["package-b"], pkgs_not_found=["package-a"]
+    )
+
+    _wheel_url = ""
+
+    async def _mock_fetch_bytes(url, *args):
+        nonlocal _wheel_url
+        _wheel_url = url
+        return b"fake wheel"
+
+    from micropip import wheelinfo
+
+    monkeypatch.setattr(wheelinfo, "fetch_bytes", _mock_fetch_bytes)
+
+    # Test with extra_index_urls parameter
+    try:
+        await manager.install(
+            "package-b", index_urls=main_index_url, extra_index_urls=extra_index_url
+        )
+    except Exception:
+        # We just check that the package was found in the extra index
+        pass
+
+    assert "package_b-1.0.0-py2.py3-none-any.whl" in _wheel_url
+
+    # Test with set_extra_index_urls
+    _wheel_url = ""
+    manager.set_index_urls([main_index_url])
+    manager.set_extra_index_urls([extra_index_url])
+
+    try:
+        await manager.install("package-b")
+    except Exception:
+        pass
+
+    assert "package_b-1.0.0-py2.py3-none-any.whl" in _wheel_url
+
+
+@pytest.mark.asyncio
+async def test_index_strategy_parameter(mock_fetch, monkeypatch):
+    manager = get_test_package_manager()
+
+    # Track which strategy is passed to find_wheel
+    from micropip.transaction import find_wheel
+
+    original_find_wheel = find_wheel
+    captured_strategy = []
+
+    def mock_find_wheel(metadata, req, strategy="first-index"):
+        captured_strategy.append(strategy)
+        return original_find_wheel(metadata, req)
+
+    monkeypatch.setattr("micropip.transaction.find_wheel", mock_find_wheel)
+
+    # Set up a mock package
+    mock_fetch.add_pkg_version("dummy", version="1.0.0")
+
+    # Test different strategies
+    strategies = ["first-index", "unsafe-first-match", "unsafe-best-match"]
+
+    for strategy in strategies:
+        captured_strategy.clear()
+        try:
+            await manager.install("dummy", index_strategy=strategy)
+            assert captured_strategy[0] == strategy
+        except Exception:
+            pass  # Ignore exceptions, we're just checking the parameter passing
+
+
+@pytest.mark.asyncio
+async def test_combined_index_urls(mock_package_index_json_api, monkeypatch):
+    manager = get_test_package_manager()
+
+    # Set up two mock servers with different packages
+    main_index_url = mock_package_index_json_api(pkgs=["package-main"])
+    extra_index_url = mock_package_index_json_api(pkgs=["package-extra"])
+
+    _wheel_urls = []
+
+    async def _mock_fetch_bytes(url, *args):
+        nonlocal _wheel_urls
+        _wheel_urls.append(url)
+        return b"fake wheel"
+
+    from micropip import wheelinfo
+
+    monkeypatch.setattr(wheelinfo, "fetch_bytes", _mock_fetch_bytes)
+
+    # Test installing packages from both main and extra indexes
+    manager.set_index_urls([main_index_url])
+    manager.set_extra_index_urls([extra_index_url])
+
+    try:
+        await manager.install(["package-main", "package-extra"])
+    except Exception:
+        pass
+
+
+@pytest.mark.asyncio
+async def test_dependency_resolution_with_multiple_indexes(
+    mock_fetch: mock_fetch_cls, monkeypatch
+):
+    """Test that dependencies are properly resolved from multiple indexes."""
+    manager = get_test_package_manager()
+
+    # Create a package with dependencies
+    main_pkg = "scikit-learn"
+    dep1 = "numpy"
+    dep2 = "scipy"
+
+    mock_fetch.add_pkg_version(main_pkg, requirements=[dep1, dep2])
+    mock_fetch.add_pkg_version(dep1)
+    mock_fetch.add_pkg_version(dep2)
+
+    await manager.install(main_pkg)
+
+    pkg_list = manager.list_packages()
+    assert main_pkg in pkg_list
+    assert dep1 in pkg_list
+    assert dep2 in pkg_list
+
+    for pkg in [main_pkg, dep1, dep2]:
+        if pkg in pkg_list:
+            manager.uninstall(pkg)
+
+    requested_urls = []
+
+    # Create a modified version of add_pkg_version that tracks URL usage
+    original_add_pkg_version = mock_fetch.add_pkg_version
+
+    def tracked_add_pkg_version(*args, **kwargs):
+        requested_urls.append(args[0])
+        return original_add_pkg_version(*args, **kwargs)
+
+    with monkeypatch.context() as m:
+        m.setattr(mock_fetch, "add_pkg_version", tracked_add_pkg_version)
+
+        # Install with a main index that only has scikit-learn, and
+        # with extra_index_urls that has the dependencies.
+        await manager.install(
+            main_pkg, extra_index_urls="https://extra-index.org/simple"
+        )
+
+        pkg_list = manager.list_packages()
+        assert main_pkg in pkg_list
+        assert dep1 in pkg_list
+        assert dep2 in pkg_list
+
+
+@pytest.mark.asyncio
+async def test_different_version_resolution_strategies(mock_fetch: mock_fetch_cls):
+    """Test different version resolution strategies with multiple indexes."""
+    manager = get_test_package_manager()
+
+    # Add a package with two versions
+    pkg_name = "test-package"
+    old_version = "1.0.0"
+    new_version = "2.0.0"
+
+    mock_fetch.add_pkg_version(pkg_name, version=old_version)
+    mock_fetch.add_pkg_version(pkg_name, version=new_version)
+
+    # With first-index, it should use the latest version available in the
+    # first index i.e., 1.0.0 as it was indexed first.
+    manager.set_index_strategy("first-index")
+    await manager.install(pkg_name)
+
+    pkg_list = manager.list_packages()
+    assert pkg_name in pkg_list
+    assert pkg_list[pkg_name].version == new_version
+
+    manager.uninstall(pkg_name)
+
+    # With unsafe-best-match, it should use the highest version
+    # across all indexes, i.e., 2.0.0.
+    manager.set_index_strategy("unsafe-best-match")
+    await manager.install(pkg_name)
+
+    pkg_list = manager.list_packages()
+    assert pkg_name in pkg_list
+    assert pkg_list[pkg_name].version == new_version
diff --git a/tests/test_transaction.py b/tests/test_transaction.py
index 822dfe0c..aa8dea7f 100644
--- a/tests/test_transaction.py
+++ b/tests/test_transaction.py
@@ -387,3 +387,70 @@ async def mock_add_wheel(self, wheel, extras, *, specifier=""):
     assert add_wheel_called.name == "black"
     # 23.7.0 is the latest version of black in the mock index
     assert str(add_wheel_called.version) == "23.7.0"
+
+
+@pytest.mark.parametrize(
+    "strategy", ["first-index", "unsafe-first-match", "unsafe-best-match"]
+)
+def test_find_wheel_with_strategy(strategy):
+    """Test that find_wheel respects different index strategies."""
+    from micropip._vendored.packaging.src.packaging.requirements import Requirement
+    from micropip.transaction import find_wheel
+
+    requirement = Requirement("dummy_module")
+
+    metadata = _pypi_metadata(
+        "dummy_module",
+        {"0.9.0": ["py3"], "1.0.0": ["py3"]},
+    )
+
+    # In all strategies, the highest compatible version should be selected
+    # when only one index is involved
+    wheel = find_wheel(metadata, requirement, strategy=strategy)
+    assert str(wheel.version) == "1.0.0"
+
+
+def test_transaction_with_strategy():
+    """Test that Transaction uses the provided index strategy."""
+    from micropip.transaction import Transaction
+
+    strategies = ["first-index", "unsafe-first-match", "unsafe-best-match"]
+
+    for strategy in strategies:
+        transaction = create_transaction(Transaction)
+        transaction.index_strategy = strategy
+
+        assert transaction.index_strategy == strategy
+
+
+@pytest.mark.asyncio
+async def test_add_requirement_from_package_index_with_strategy(monkeypatch):
+    """Test that _add_requirement_from_package_index is passing the strategy to find_wheel."""
+    from micropip._vendored.packaging.src.packaging.requirements import Requirement
+    from micropip.transaction import Transaction, find_wheel
+
+    async def mock_query_package(name, index_urls, fetch_kwargs, strategy=None):
+        # just return a simple metadata object
+        return _pypi_metadata(name, {"1.0.0": ["py3"]})
+
+    original_find_wheel = find_wheel
+    captured_strategy = []
+
+    def mock_find_wheel(metadata, req, strategy=None):
+        captured_strategy.append(strategy)
+        return original_find_wheel(metadata, req)
+
+    monkeypatch.setattr("micropip.package_index.query_package", mock_query_package)
+    monkeypatch.setattr("micropip.transaction.find_wheel", mock_find_wheel)
+
+    transaction = create_transaction(Transaction)
+    transaction.index_strategy = "unsafe-best-match"
+
+    async def mock_add_wheel(self, wheel, extras, **kwargs):
+        pass
+
+    monkeypatch.setattr(Transaction, "add_wheel", mock_add_wheel)
+
+    req = Requirement("some-package")
+    await transaction._add_requirement_from_package_index(req)
+    assert captured_strategy[0] == "unsafe-best-match"