Scope HTTP client redirect following to the request's origin

docs/client/transports.md

@@ -29,7 +29,7 @@
 --8<-- "docs_src/client_transports/tutorial002.py"
 ```
 
-That is the whole production client. `Client` wraps the URL in `streamable_http_client(...)` for you, on top of an `httpx.AsyncClient` configured the way MCP needs: `follow_redirects=True`, a 30-second timeout for connect/write/pool, and a 300-second read timeout because the server may hold a response stream open.
+That is the whole production client. `Client` wraps the URL in `streamable_http_client(...)` for you, on top of an `httpx.AsyncClient` configured the way MCP needs: same-origin redirect handling, a 30-second timeout for connect/write/pool, and a 300-second read timeout because the server may hold a response stream open.
 
 !!! check
     A `Client` you have constructed is **not** connected. Construction only picks the transport;

docs/migration.md

@@ -1595,14 +1595,15 @@ async with streamablehttp_client(
 
 ```python
 import httpx
+from mcp import create_mcp_http_client
 from mcp.client.streamable_http import streamable_http_client
 
-# Configure headers, timeout, and auth on the httpx.AsyncClient
-http_client = httpx.AsyncClient(
+# Configure headers, timeout, and auth on the client. create_mcp_http_client
+# applies the SDK defaults (timeouts, same-origin redirect handling).
+http_client = create_mcp_http_client(
     headers={"Authorization": "Bearer token"},
     timeout=httpx.Timeout(30, read=300),
     auth=my_auth,
-    follow_redirects=True,
 )
 
 async with http_client:
@@ -1613,7 +1614,26 @@ async with http_client:
         ...
 ```
 
-v1's internal client set `follow_redirects=True`; set it explicitly when supplying your own `httpx.AsyncClient` to preserve that behavior.
+Prefer `create_mcp_http_client` when supplying your own client: a plain `httpx.AsyncClient` does not follow redirects at all, and configuring `follow_redirects=True` yourself sends everything on the client (headers, auth, bodies) to whichever server a redirect names.
+
+### HTTP clients only follow same-origin redirects
+
+Clients created by the SDK (including `Client("http://...")`, `sse_client`, and the
+default client inside `streamable_http_client`) now vet redirect targets before
+following. Redirects that stay on the same origin (scheme, host, and port) and
+http-to-https upgrades of the same host still work; any other redirect raises
+`mcp.RedirectError` naming the target instead of being followed. Everything
+configured on a client - headers, auth, request bodies - is sent to whichever
+server it talks to, so requests now stay with the server you configured, and a
+misconfigured URL fails with a clear error instead of silently bouncing.
+
+To migrate: connect to the final URL the error names. If your deployment
+genuinely requires following a redirect to a different origin, supply your own
+`httpx.AsyncClient(follow_redirects=True)` - after verifying you trust every
+destination in the chain.
+
+`create_mcp_http_client` (the SDK's client factory) and `RedirectError` are now
+exported from the top-level `mcp` package.
 
 ### `get_session_id` callback removed from `streamable_http_client`
 
@@ -1638,6 +1658,7 @@ async with streamable_http_client(url) as (read_stream, write_stream, get_sessio
 
 ```python
 import httpx
+from mcp import create_mcp_http_client
 from mcp.client.streamable_http import streamable_http_client
 
 # Option 1: Simply ignore if you don't need the session ID
@@ -1653,10 +1674,8 @@ async def capture_session_id(response: httpx.Response) -> None:
     if session_id:
         captured_session_ids.append(session_id)
 
-http_client = httpx.AsyncClient(
-    event_hooks={"response": [capture_session_id]},
-    follow_redirects=True,
-)
+http_client = create_mcp_http_client()
+http_client.event_hooks["response"].append(capture_session_id)
 
 async with http_client:
     async with streamable_http_client(url, http_client=http_client) as (read_stream, write_stream):

docs/run/asgi.md

@@ -94,7 +94,7 @@ That trailing `/mcp` is `streamable_http_path`. Set it to `"/"` and the mount pr
 --8<-- "docs_src/asgi/tutorial004.py"
 ```
 
-Now clients connect to `/notes`, not `/notes/mcp`.
+Now clients connect to `/notes/`, not `/notes/mcp`. (The trailing slash is the canonical path for this mount shape; the bare `/notes` answers with a same-origin redirect to it.)
 
 ## CORS for browser clients
 

docs_src/client_transports/tutorial003.py

@@ -1,14 +1,13 @@
 import httpx
 
-from mcp import Client
+from mcp import Client, create_mcp_http_client
 from mcp.client.streamable_http import streamable_http_client
 
 
 async def main() -> None:
-    async with httpx.AsyncClient(
+    async with create_mcp_http_client(
         headers={"Authorization": "Bearer ..."},
         timeout=httpx.Timeout(30.0, read=300.0),
-        follow_redirects=True,
     ) as http_client:
         transport = streamable_http_client("http://localhost:8000/mcp", http_client=http_client)
         async with Client(transport) as client:

docs_src/identity_assertion/tutorial001.py

@@ -1,10 +1,9 @@
 import time
 import uuid
 
-import httpx
 import jwt
 
-from mcp import Client
+from mcp import Client, create_mcp_http_client
 from mcp.client.auth.extensions.identity_assertion import IdentityAssertionOAuthProvider
 from mcp.client.streamable_http import streamable_http_client
 from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
@@ -62,7 +61,7 @@ async def fetch_id_jag(audience: str, resource: str) -> str:
 
 
 async def main() -> None:
-    async with httpx.AsyncClient(auth=oauth, follow_redirects=True) as http_client:
+    async with create_mcp_http_client(auth=oauth) as http_client:
         transport = streamable_http_client("http://localhost:8001/mcp", http_client=http_client)
         async with Client(transport) as client:
             result = await client.list_tools()

docs_src/oauth_clients/tutorial001.py

@@ -1,9 +1,8 @@
 from urllib.parse import parse_qs, urlparse
 
-import httpx
 from pydantic import AnyUrl
 
-from mcp import Client
+from mcp import Client, create_mcp_http_client
 from mcp.client.auth import AuthorizationCodeResult, OAuthClientProvider
 from mcp.client.streamable_http import streamable_http_client
 from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken
@@ -55,7 +54,7 @@ async def wait_for_callback() -> AuthorizationCodeResult:
 
 
 async def main() -> None:
-    async with httpx.AsyncClient(auth=oauth, follow_redirects=True) as http_client:
+    async with create_mcp_http_client(auth=oauth) as http_client:
         transport = streamable_http_client("http://localhost:8001/mcp", http_client=http_client)
         async with Client(transport) as client:
             result = await client.list_tools()

docs_src/oauth_clients/tutorial002.py

@@ -1,6 +1,4 @@
-import httpx
-
-from mcp import Client
+from mcp import Client, create_mcp_http_client
 from mcp.client.auth.extensions.client_credentials import ClientCredentialsOAuthProvider
 from mcp.client.streamable_http import streamable_http_client
 from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
@@ -34,7 +32,7 @@ async def set_client_info(self, client_info: OAuthClientInformationFull) -> None
 
 
 async def main() -> None:
-    async with httpx.AsyncClient(auth=oauth, follow_redirects=True) as http_client:
+    async with create_mcp_http_client(auth=oauth) as http_client:
         transport = streamable_http_client("http://localhost:8001/mcp", http_client=http_client)
         async with Client(transport) as client:
             result = await client.list_tools()

examples/clients/simple-auth-client/mcp_simple_auth_client/main.py

@@ -17,7 +17,7 @@
 from typing import Any
 from urllib.parse import parse_qs, urlparse
 
-import httpx
+from mcp import create_mcp_http_client
 from mcp.client._transport import ReadStream, WriteStream
 from mcp.client.auth import AuthorizationCodeResult, OAuthClientProvider, TokenStorage
 from mcp.client.session import ClientSession
@@ -233,7 +233,7 @@ async def _default_redirect_handler(authorization_url: str) -> None:
                     await self._run_session(read_stream, write_stream)
             else:
                 print("📡 Opening StreamableHTTP transport connection with auth...")
-                async with httpx.AsyncClient(auth=oauth_auth, follow_redirects=True) as custom_client:
+                async with create_mcp_http_client(auth=oauth_auth) as custom_client:
                     async with streamable_http_client(url=self.server_url, http_client=custom_client) as (
                         read_stream,
                         write_stream,

examples/servers/simple-tool/mcp_simple_tool/server.py

@@ -1,15 +1,18 @@
 import anyio
 import click
+import httpx
 import mcp_types as types
 from mcp.server import Server, ServerRequestContext
-from mcp.shared._httpx_utils import create_mcp_http_client
 
 
 async def fetch_website(
     url: str,
 ) -> list[types.ContentBlock]:
     headers = {"User-Agent": "MCP Test Server (github.com/modelcontextprotocol/python-sdk)"}
-    async with create_mcp_http_client(headers=headers) as client:
+    # A general-purpose web fetch wants ordinary browser-like redirect
+    # behavior; create_mcp_http_client is for talking to a configured MCP
+    # endpoint and only follows same-origin redirects.
+    async with httpx.AsyncClient(headers=headers, follow_redirects=True, timeout=30.0) as client:
         response = await client.get(url)
         response.raise_for_status()
         return [types.TextContent(type="text", text=response.text)]

examples/snippets/clients/identity_assertion_client.py

@@ -16,9 +16,7 @@
 
 import asyncio
 
-import httpx
-
-from mcp import ClientSession
+from mcp import ClientSession, create_mcp_http_client
 from mcp.client.auth.extensions.identity_assertion import IdentityAssertionOAuthProvider
 from mcp.client.streamable_http import streamable_http_client
 from mcp.shared.auth import OAuthClientInformationFull, OAuthToken
@@ -66,7 +64,7 @@ async def main() -> None:
         scope="user",
     )
 
-    async with httpx.AsyncClient(auth=oauth_auth, follow_redirects=True) as http_client:
+    async with create_mcp_http_client(auth=oauth_auth) as http_client:
         async with streamable_http_client("http://localhost:8001/mcp", http_client=http_client) as (read, write):
             async with ClientSession(read, write) as session:
                 await session.initialize()

examples/snippets/clients/oauth_client.py

@@ -9,10 +9,9 @@
 import asyncio
 from urllib.parse import parse_qs, urlparse
 
-import httpx
 from pydantic import AnyUrl
 
-from mcp import ClientSession
+from mcp import ClientSession, create_mcp_http_client
 from mcp.client.auth import AuthorizationCodeResult, OAuthClientProvider, TokenStorage
 from mcp.client.streamable_http import streamable_http_client
 from mcp.shared.auth import OAuthClientInformationFull, OAuthClientMetadata, OAuthToken
@@ -72,7 +71,7 @@ async def main():
         callback_handler=handle_callback,
     )
 
-    async with httpx.AsyncClient(auth=oauth_auth, follow_redirects=True) as custom_client:
+    async with create_mcp_http_client(auth=oauth_auth) as custom_client:
         async with streamable_http_client("http://localhost:8001/mcp", http_client=custom_client) as (read, write):
             async with ClientSession(read, write) as session:
                 await session.initialize()

src/mcp/__init__.py

@@ -65,6 +65,7 @@
 from .client.stdio import StdioServerParameters, stdio_client
 from .server.session import ServerSession
 from .server.stdio import stdio_server
+from .shared._httpx_utils import RedirectError, create_mcp_http_client
 from .shared.exceptions import MCPDeprecationWarning, MCPError, UrlElicitationRequiredError
 from .shared.uri_template import InvalidUriTemplate, UriTemplate
 
@@ -108,6 +109,7 @@
     "PromptsCapability",
     "ReadResourceRequest",
     "ReadResourceResult",
+    "RedirectError",
     "Resource",
     "ResourcesCapability",
     "ResourceUpdatedNotification",
@@ -137,6 +139,7 @@
     "UriTemplate",
     "UrlElicitationRequiredError",
     "InvalidUriTemplate",
+    "create_mcp_http_client",
     "stdio_client",
     "stdio_server",
 ]

src/mcp/client/auth/extensions/identity_assertion.py

@@ -39,6 +39,7 @@
     union_scopes,
     validate_metadata_issuer,
 )
+from mcp.shared._httpx_utils import redirect_error
 from mcp.shared.auth import JWT_BEARER_GRANT_TYPE, OAuthClientInformationFull, OAuthToken
 from mcp.shared.auth_utils import calculate_token_expiry, resource_url_from_server_url
 
@@ -199,6 +200,8 @@ async def async_auth_flow(self, request: httpx.Request) -> AsyncGenerator[httpx.
 
             assertion = await self._assertion_provider(self._issuer, self._resource)
             token_response = yield self._build_token_request(scope_to_request, assertion)
+            if token_response.has_redirect_location:
+                raise redirect_error(token_response, context="OAuth token exchange request")
             if token_response.status_code != 200:
                 body = (await token_response.aread()).decode(errors="replace")
                 raise OAuthTokenError(f"Token exchange failed ({token_response.status_code}): {body}")

src/mcp/client/auth/oauth2.py

@@ -41,6 +41,7 @@
     validate_authorization_response_iss,
     validate_metadata_issuer,
 )
+from mcp.shared._httpx_utils import redirect_error
 from mcp.shared.auth import (
     AuthorizationCodeResult,
     OAuthClientInformationFull,
@@ -413,9 +414,11 @@
         token_data, headers = self.context.prepare_token_auth(token_data, headers)
 
         return httpx.Request("POST", token_url, data=token_data, headers=headers)
 
     async def _handle_token_response(self, response: httpx.Response) -> None:
         """Handle token exchange response."""
+        if response.has_redirect_location:
+            raise redirect_error(response, context="OAuth token request")
         if response.status_code not in {200, 201}:
             body = await response.aread()
             body_text = body.decode("utf-8")
@@ -468,6 +471,8 @@
 
     async def _handle_refresh_response(self, response: httpx.Response) -> bool:
         """Handle token refresh response. Returns True if successful."""
+        if response.has_redirect_location:
+            raise redirect_error(response, context="OAuth token refresh request")
         if response.status_code != 200:
             logger.warning(f"Token refresh failed: {response.status_code}")
             self.context.clear_tokens()

src/mcp/client/auth/utils.py

@@ -6,6 +6,7 @@
 from pydantic import AnyUrl, ValidationError
 
 from mcp.client.auth import OAuthFlowError, OAuthRegistrationError, OAuthTokenError
+from mcp.shared._httpx_utils import redirect_error
 from mcp.shared.auth import (
     OAuthClientInformationFull,
     OAuthClientMetadata,
@@ -206,6 +207,10 @@ async def handle_protected_resource_response(
     Returns:
         ProtectedResourceMetadata if successfully discovered, None if we should try next URL
     """
+    if response.has_redirect_location:
+        # A redirect here would silently move discovery to another URL;
+        # fail loudly instead of treating it as a miss.
+        raise redirect_error(response, context="OAuth protected resource metadata request")
     if response.status_code == 200:
         try:
             content = await response.aread()
@@ -221,6 +226,10 @@ async def handle_protected_resource_response(
 
 
 async def handle_auth_metadata_response(response: Response) -> tuple[bool, OAuthMetadata | None]:
+    if response.has_redirect_location:
+        # A redirect here would silently abandon discovery (any non-4xx stops
+        # the fallback chain); fail loudly instead.
+        raise redirect_error(response, context="OAuth authorization server metadata request")
     if response.status_code == 200:
         try:
             content = await response.aread()
@@ -293,6 +302,8 @@ def create_client_registration_request(
 
 async def handle_registration_response(response: Response) -> OAuthClientInformationFull:
     """Handle registration response."""
+    if response.has_redirect_location:
+        raise redirect_error(response, context="OAuth client registration request")
     if response.status_code not in (200, 201):
         await response.aread()
         raise OAuthRegistrationError(f"Registration failed: {response.status_code} {response.text}")