Should an API client class be reusable?

It all depends on the work the needs to be done during the initialization.

When you do:

with ApiClient() as client:
    ...

I suppose that there are a series of operations that need to be done before you start doing the actual queries. It may be, for instance, that you need to retrieve the URI of the API from the settings, or initialize the user, or—who knows?—make a check to the API to see if it is responding (and if not, handle it on client side in a very specific way).

All those tasks may take CPU cycles that you are not ready to spend on every request. In this case, keeping an instance of the ApiClient class may make sense.

Another reason to have one instance is dependency injection. If at some point you need to inject the API client, rather than initializing it every time (for instance in order to render the consumer class—the class that relies on the API client—testable, making it possible to replace ApiClient by a mock), then having one instance injected in the constructor is a common solution (although nothing prevents you from injecting a function that would create an instance).

Finally, a third reason to use a long-lived instance would be to keep the resources active. For instance, ApiClient may want to reuse the same HTTP connection for multiple requests, instead of creating a connection every time (which also means performing TLS handshake for every with block).

I'm going to side-step the issue of whether this is worth doing and just focus on a simple coding solution which cleans things up:

class ApiClientPool:
    def __init__(self, api_key: str = os.environ["API_KEY"]) -> None:
        """Instantiate a new API client pool."""
        self.api_key = api_key

    def client():
        return ApiClient(self.api_key)

class ApiClient:
    def __init__(self, api_key) -> None:
        """Instantiate a new API client."""
        self.api_key = api_key

    def __enter__(self):
        headers = {"Api-Key": self.api_key}
        base_url = "https://login.smoobu.com"
        self.client = httpx.Client(base_url=base_url, headers=headers)

    def __exit__(self, exception_type, exception_value, exception_traceback):
        self.client.close()

    def _request(self, method: str, endpoint: str, data: dict | None = None):
        request = self.client.build_request(method=method, url=endpoint, data=data)
        response = self.client.send(request)
        response.raise_for_status()
        return response.json()

    def get_user(self):
        return self._request("GET", "/api/me")

ApiClientPool is just the first name that came to mind so don't get hung up on it. The use of this becomes:

with pool.client() as client:
   client.get_user()

The main advantage here is that you can pass/inject a pool instance instead of the API_KEY.

Depending on the context this is used in, I think a module-level solution instead of the additional class would be fine in a lot of cases. Of course, that would only make sense if there's a single API key per application instance. If you have more than one thing that you need to share across client instances, this kind of thing becomes more obviously useful. It also positions you to actually pool connections if that is desirable.