@@ -137,6 +137,7 @@ For a guided walkthrough — authenticating, running an Actor, and reading its r
 - **Convenience methods** — `call()`, `wait_for_finish()`, nested resource access, and other shortcuts that hide platform quirks ([Convenience methods](https://docs.apify.com/api/client/python/docs/concepts/convenience-methods)).
 - **Pluggable HTTP layer** — use the default [Impit](https://github.com/apify/impit)-based client, opt in to the built-in [HTTPX2](https://github.com/pydantic/httpx2) client, or plug in any custom implementation ([HTTP clients](https://docs.apify.com/api/client/python/docs/concepts/custom-http-clients)).
 - **Structured errors** — every API error surfaces as an [`ApifyApiError`](https://docs.apify.com/api/client/python/reference/class/ApifyApiError) with HTTP-specific subclasses for precise handling ([Error handling](https://docs.apify.com/api/client/python/docs/concepts/error-handling)).
+- **Server Actors** — send HTTP requests to an Actor's server interface (formerly Actor Standby), and get the server's URL and OpenAPI specification ([Server Actors](https://docs.apify.com/api/client/python/docs/concepts/server-actors)).
 - **Debug logging** — opt-in structured logging on the `apify_client` logger captures request URLs, status codes, retry attempts, and more ([Logging](https://docs.apify.com/api/client/python/docs/concepts/logging)).
 
 ## Usage examples
 
@@ -100,7 +100,7 @@ The base classes and the response protocol are available from the `apify_client.
 
 The public `call` method provides the shared request pipeline. A concrete transport implements these hooks:
 
-- `send_request(...)` sends one prepared request and returns an `HttpResponse`, error statuses included. It receives the URL with the query parameters already encoded into it, the headers with the client's default headers already merged in, the body, and the timeout for this attempt in seconds. The body is either `bytes`, already serialized and compressed, or an iterator of `bytes` chunks for a streamed body, which is an async iterator in the asynchronous client. The inherited `call` needs it, so every transport adapter has to implement it. Let the HTTP library's exceptions propagate unwrapped, and leave status handling and <ApiLink to="class/ApifyApiError">`ApifyApiError`</ApiLink> to `call`.
+- `send_request(...)` sends one prepared request and returns an `HttpResponse`, error statuses included. It receives the URL with the query parameters already encoded into it, the headers with the client's default headers already merged in, the body, and the timeout for this attempt in seconds. The body is either `bytes`, already serialized and compressed, or an iterator of `bytes` chunks for a streamed body, which is an async iterator in the asynchronous client. The inherited `call` needs it, so every transport adapter has to implement it. Let the HTTP library's exceptions propagate unwrapped, and leave status handling and <ApiLink to="class/ApifyApiError">`ApifyApiError`</ApiLink> to `call`. It also takes `follow_redirects`, which `call` passes as `False` for a request to an Actor's server: return a redirect response as it is then, since the request carries the API token.
 - `is_retryable_transport_error(exc)` classifies transport failures for the shared retry loop. The default classifies nothing as retryable, so a transport that doesn't override it gives up on the first connection failure.
 - `is_timeout_error(exc)` identifies transport-specific timeout exceptions for higher-level client features. The default recognizes Python's `TimeoutError`. Timeout classification is independent of retryability, so a timeout the retry loop should retry has to be listed in `is_retryable_transport_error` too.
 - `close()` or `aclose()` closes resources owned by the transport. The default does nothing, which is correct for a transport that owns no pool or session.
@@ -151,7 +151,7 @@ Use the <ApiLink to="class/ApifyClient#with_custom_http_client">`ApifyClient.wit
 After that, all API calls made through the client will go through your custom HTTP client.
 
 :::warning
-If you override `call` itself, your implementation becomes responsible for request preparation, retries, timeouts, API error conversion, logging, and statistics. Implementing the transport hooks and inheriting `call` keeps the shared behavior.
+If you override `call` itself, your implementation becomes responsible for request preparation, retries, timeouts, API error conversion, logging, and statistics. It also has to honor the `compression`, `authorization_header`, `raise_for_status`, `retry_status_codes`, `retry_transport_errors`, and `follow_redirects` arguments. <ApiLink to="class/ActorServerClient#request">`ActorServerClient.request`</ApiLink> relies on them to keep the API token away from the Actor's code, to return the server's error responses, and to avoid sending a request to the Actor twice. Implementing the transport hooks and inheriting `call` keeps the shared behavior.
 :::
 
 If you override `call` and prepare requests with the inherited helpers, a streamed body arrives as a <ApiLink to="class/StreamedRequestBody">`StreamedRequestBody`</ApiLink>. Send its `iter_bytes()` or `aiter_bytes()`, and send the body a second time only when `rewindable` is true, after calling `rewind()`. For what the client streams and how, see [Streaming uploads](./09_streaming.mdx#streaming-uploads).
 
@@ -0,0 +1,87 @@
+---
+id: server-actors
+title: Server Actors
+description: Send HTTP requests to Server Actors (formerly Actor Standby), and get their URL and OpenAPI specification.
+keywords: [server actor, server interface, standby, actor standby, standby_url, ActorServerClient]
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+import CodeBlock from '@theme/CodeBlock';
+import ApiLink from '@theme/ApiLink';
+
+import ServerAsyncExample from '!!raw-loader!./code/14_server_async.py';
+import ServerSyncExample from '!!raw-loader!./code/14_server_sync.py';
+import ServerUrlSpecAsyncExample from '!!raw-loader!./code/14_server_url_spec_async.py';
+import ServerUrlSpecSyncExample from '!!raw-loader!./code/14_server_url_spec_sync.py';
+
+A [Server Actor](https://docs.apify.com/platform/actors/running/standby) (formerly Actor Standby) runs a web server. You call it over HTTP, and the platform keeps a run ready to answer, so each call skips the run startup.
+
+:::note Formerly Actor Standby
+
+Actor Standby is the former name of Server Actors, and it'll be deprecated. The platform documentation and the API still use it, for example in the Actor's `standby_url` and `actor_standby` fields, and in the `actor_standby_*` arguments of `ActorClient.update`. In the client, `ActorClient.standby` is a deprecated alias of `ActorClient.server` that will be removed in v4.
+
+:::
+
+To work with a Server Actor, get its server client with <ApiLink to="class/ActorClient#server">`ActorClient.server`</ApiLink>. To send a request, use <ApiLink to="class/ActorServerClient#request">`ActorServerClient.request`</ApiLink>. It takes the path on the Actor's server, and optionally the HTTP method, query parameters, headers, and a body:
+
+<Tabs>
+    <TabItem value="AsyncExample" label="Async client" default>
+        <CodeBlock className="language-python">
+            {ServerAsyncExample}
+        </CodeBlock>
+    </TabItem>
+    <TabItem value="SyncExample" label="Sync client">
+        <CodeBlock className="language-python">
+            {ServerSyncExample}
+        </CodeBlock>
+    </TabItem>
+</Tabs>
+
+The method returns the server's response. To read a large body in chunks, pass `stream=True` and close the response when you're done with it. To find out which endpoints an Actor serves, see its page in [Apify Store](https://apify.com/store), its README, or its OpenAPI specification. For details, see [Server URL and OpenAPI specification](#server-url-and-openapi-specification).
+
+## How the request is sent
+
+Note that:
+
+- The client takes the server's URL from the Actor's `standby_url`. It fetches the Actor from the API on the first call and reuses the URL for later calls through the same `ActorClient`. If the Actor isn't a Server Actor, the server client raises an `ApifyClientError`.
+- The path is always resolved against that URL, so a path can't send the request to another host.
+- By default, the request body is sent uncompressed, since the Actor's server may not decode a compressed body. If the server decodes it, pass `compression`, for example `compression='gzip'`. The client then compresses large bodies the same way as for API calls.
+
+## Server URL and OpenAPI specification
+
+The Actor server client also gives you the server's URL and its OpenAPI specification:
+
+- <ApiLink to="class/ActorServerClient#get_url">`ActorServerClient.get_url`</ApiLink> returns the server's URL. It fetches and reuses the URL the same way as `request`.
+- <ApiLink to="class/ActorServerClient#get_openapi_spec">`ActorServerClient.get_openapi_spec`</ApiLink> returns the server's OpenAPI specification as a `dict`. It's the [web server schema](https://docs.apify.com/platform/actors/development/actor-definition/web-server-schema) from the Actor's definition, taken from the build that serves the server interface. That's the build set in the Actor's `actor_standby.build` field, or `latest` if none is set. If the Actor doesn't define a web server schema, the method returns `None`.
+
+The following example prints the server's URL and the paths of its endpoints:
+
+<Tabs>
+    <TabItem value="AsyncExample" label="Async client" default>
+        <CodeBlock className="language-python">
+            {ServerUrlSpecAsyncExample}
+        </CodeBlock>
+    </TabItem>
+    <TabItem value="SyncExample" label="Sync client">
+        <CodeBlock className="language-python">
+            {ServerUrlSpecSyncExample}
+        </CodeBlock>
+    </TabItem>
+</Tabs>
+
+## Authentication
+
+The request carries the client's API token in the `X-Apify-Authorization` header. The platform removes the token before it forwards the request, so the token doesn't reach the Actor's code. The method doesn't follow redirects and returns a redirect response as it is, since following it would send the token to a host the Actor's code picked.
+
+The headers you pass in `headers` reach the Actor's server as they are. If the Actor reads the `Authorization` header for its own authentication, pass that header in `headers`.
+
+For details, see [How do I authenticate my requests](https://docs.apify.com/platform/actors/running/standby#how-do-i-authenticate-my-requests) in the platform documentation.
+
+## Timeouts, retries, and errors
+
+When no server run is ready, the first request waits for the platform to start one. The method uses the `long` timeout tier by default for that reason. You can pass a different `timeout`, the same way as for API calls. For details, see [Timeouts](./11_timeouts.mdx).
+
+The method returns the server's response whatever its status, so check `status_code` before you use the body. Only rate-limit (429) and Service Unavailable (503) responses are retried, with the client's retry settings. Once the retries run out, the method returns the last response. The platform sends these when it can't pass the request to a server run, but the Actor's code can return them too, and then a retry sends the request to the Actor again. Network errors and timeouts aren't retried, since the Actor may have already handled the request. For details, see [Retries](./05_retries.mdx).
+
+The method raises only when it doesn't get a response from the server: an `ApifyApiError` when the API can't return the Actor, for example because it doesn't exist, an `ApifyClientError` when it isn't a Server Actor, or the HTTP library's error when the request fails or times out. For details, see [Error handling](./04_error_handling.mdx).
@@ -21,6 +21,7 @@ async def send_request(
         content: bytes | AsyncIterator[bytes] | None,
         timeout: float | None,
         stream: bool,
+        follow_redirects: bool = True,
     ) -> HttpResponse:
         """Send one request through the custom transport."""
         raise NotImplementedError
 
@@ -21,6 +21,7 @@ def send_request(
         content: bytes | Iterator[bytes] | None,
         timeout: float | None,
         stream: bool,
+        follow_redirects: bool = True,
     ) -> HttpResponse:
         """Send one request through the custom transport."""
         raise NotImplementedError
 
@@ -0,0 +1,25 @@
+from http import HTTPStatus
+
+from apify_client import ApifyClientAsync
+
+TOKEN = 'MY-APIFY-TOKEN'
+
+
+async def main() -> None:
+    apify_client = ApifyClientAsync(TOKEN)
+    actor_server_client = apify_client.actor('username/actor-name').server()
+
+    # Send a GET request to the /search endpoint of the Actor's server. The method
+    # returns error responses too, so check the status first.
+    response = await actor_server_client.request('/search', params={'q': 'apify'})
+    if response.status_code != HTTPStatus.OK:
+        raise RuntimeError(f'Search failed with status {response.status_code}')
+    print(response.json())
+
+    # Send a POST request with a JSON body.
+    response = await actor_server_client.request(
+        '/items',
+        method='POST',
+        json={'url': 'https://apify.com'},
+    )
+    print(response.status_code)
@@ -0,0 +1,25 @@
+from http import HTTPStatus
+
+from apify_client import ApifyClient
+
+TOKEN = 'MY-APIFY-TOKEN'
+
+
+def main() -> None:
+    apify_client = ApifyClient(TOKEN)
+    actor_server_client = apify_client.actor('username/actor-name').server()
+
+    # Send a GET request to the /search endpoint of the Actor's server. The method
+    # returns error responses too, so check the status first.
+    response = actor_server_client.request('/search', params={'q': 'apify'})
+    if response.status_code != HTTPStatus.OK:
+        raise RuntimeError(f'Search failed with status {response.status_code}')
+    print(response.json())
+
+    # Send a POST request with a JSON body.
+    response = actor_server_client.request(
+        '/items',
+        method='POST',
+        json={'url': 'https://apify.com'},
+    )
+    print(response.status_code)
@@ -0,0 +1,17 @@
+from apify_client import ApifyClientAsync
+
+TOKEN = 'MY-APIFY-TOKEN'
+
+
+async def main() -> None:
+    apify_client = ApifyClientAsync(TOKEN)
+    actor_server_client = apify_client.actor('username/actor-name').server()
+
+    # Get the URL of the Actor's server.
+    server_url = await actor_server_client.get_url()
+    print(server_url)
+
+    # Get the OpenAPI specification and list the server's endpoints.
+    spec = await actor_server_client.get_openapi_spec()
+    if spec is not None:
+        print(list(spec['paths']))
@@ -0,0 +1,17 @@
+from apify_client import ApifyClient
+
+TOKEN = 'MY-APIFY-TOKEN'
+
+
+def main() -> None:
+    apify_client = ApifyClient(TOKEN)
+    actor_server_client = apify_client.actor('username/actor-name').server()
+
+    # Get the URL of the Actor's server.
+    server_url = actor_server_client.get_url()
+    print(server_url)
+
+    # Get the OpenAPI specification and list the server's endpoints.
+    spec = actor_server_client.get_openapi_spec()
+    if spec is not None:
+        print(list(spec['paths']))
@@ -100,13 +100,15 @@ async def send_request(
         content: bytes | AsyncIterator[bytes] | None,
         timeout: float | None,
         stream: bool,
+        follow_redirects: bool = True,
     ) -> HttpResponse:
         response = await self._session.request(
             method=method,
             url=url,
             headers=headers,
             data=content,
             timeout=aiohttp.ClientTimeout(total=timeout),
+            allow_redirects=follow_redirects,
         )
         adapted_response = AiohttpResponse(response)