Well, an “extra HTTP call” is any call besides the one required for the client to access my API, in this case is an extra call to generate an access token.
Why does it matter? In words of the client: “making a call to generate a token is slow”

As for client side token generation…
Never trust the client.

Say you hash the password client side. At this point, you have to have static salt (which can be extracted from clients), and the hashed result becomes the password.
All of this greatly weakens the security.

If the client sends a username, and the server returns a salt, then it’s a bit more secure. At least this way the salt can be randomly generated for each user.
But, it’s an extra API call.

You could use the username as the salt. This makes things a bit better, but you open yourself to being rainbow-tabled for usernames like “admin”. Also, the salt doesn’t change when a password is updated.

Here’s a SE post that kinda pertains to what you want:
https://security.stackexchange.com/questions/93395/how-to-do-client-side-hashing-of-password-using-bcrypt

This one has a section on client side hashing:
https://security.stackexchange.com/questions/211/how-to-securely-hash-passwords/31846#31846

Edit:

Client side key generation isn’t worth it. There aren’t any good implementations.
I think one of the answers linked above alludes to the following solution:

Do a double salt:

Username & password get bcrypted (or similar) together in the client. The username-as-salt reduces the parallel of brute force attacks to a single user (ie if an attacker has a bunch of hashes of different passwords for the same user, they can brute force them all at the same time - they know the salt)

Username and hash is sent along with the request (the hash essentially becomes the new password without leaking it in plaintext in server logs, gateways, proxies etc.).

The server then retrieves the users salt from the database, hashes it again using the appropriate salt.

This way, at least the data at rest is fairly well protected. But I’m not a crypto guy. I have learned to follow the herd when it comes to authentication and security.
And I don’t think there is actually a decent way to do this that actually provides the kind of security required these days.

Couldn’t you do something like JWT except allow the client to slap on their credentials to any initial request?

From the backend side that means that if there is no valid token, you can check the request body for the credentials. If they’re not there, then it’s an unauthorized request.

You’re eliminating a singular request in a long period of time at the cost of adding complexity to both client and backend but if the customer wants to be silly that’s their fault

Is the client a web browser used by an end user? Or is it a trusted environment?

Because if it’s a trusted environment (server to server) then you could add an extra field to your user table for api_key, and an extra tokens table to your database.
Think of githubs legacy access token system (and, again, it’s now legacy because it’s a dated and insecure way of doing it).
Each user gets a randomly generated 16 character string as their api_key.
Then the user is given a way to create/regenerate/delete records into the tokens table: a friendly name, user id relation, and finally a randomly generated 16 character string as for the token.
You could even add some sort of token expiry date, to limit the timeframe of damage for a leaked key.

Another option for untrusted environments (egba we browser) is JWT. It’s used a lot for microservices.
It’s a token with a lifespan minted by your Auth server. Anyone can decode the token and inspect the payload, so it’s not secure for storing passwords but it’s great for storing user ID and perhaps access scopes. The token can be verified by anyone to ensure the token is authentic and hasn’t been tampered with.
But only servers that know the JWT secret can mint them.
The issue with JWTs is that there is no way to revoke them. If you mint a jwt that’s valid for 4 years, the only way to invalidate it is by having all servers share a list of revoked tokens - or by having all servers call back to the Auth server that minted the token (which probably maintains a revoke list) to check it’s still valid. And, there is no way to “ban” a user if they still have a valid token.
Essentially the JWT is keys to the kingdom, and they are hard to get back.
Which is why they often have lifetimes of 5-30 minutes, and - you guessed it - are issued along with a refresh token.

Edit:
There is SRP (6a).
https://github.com/LinusU/secure-remote-password
All the SRP projects I can find haven’t been updated in 5 years - not a good look for a security system.

The problem with all of these things is that they haven’t been deemed secure enough or provide enough additional benefits for widespread adoption.
The money has gone into oauth, oidc, saml, jwt etc.

Neat. I can help with some of these concepts:

• WSSE is just a reimplantation of Basic Auth, but it has a dramatically worse security posture today, than Basic Auth. WSSE is complex and deprectaed. Basic Auth is not wonderful, but is simple and is still being patched.
• On that note, Basic Auth is almost certainly what you want here.
• Don’t use cleartext for any of this (obviously). It need HTTPS or it’ll get owned immediately.
• Don’t do an extra encryption step inside your HTTPS connection. HTTPS isn’t perfect security, but if a job doesn’t call for OAuth and token rotation, it also probably also doesn’t call for a needless extra layer of encryption on the wire.
• Do encrypt your data at rest.
• None of your source code should be doing any kind of encrytion.
• Encryption on the wire should be via HTTPS.
• Encrytion in storage (at rest) should be via a database or disk drive setting.
• There’s no benefit to encrytping data that has already been encrypted, and there’s real risks of accidentally ruining the protection of the original encryption. But mostly, additional encryption just makes life hard for your ops team while adding zero security value.

You can protect your Basic Auth password simply by storing it in cleartext where it is needed with reasonable protections

(This is again assuming your use case is actually okay for not having OAuth. If it’s health data, suck it up and do real OAuth, obviously.)

Reasonable protections for your Basic Auth passwords:

• Make sure nobody except your administration team can read the file where it is stored.
• Have separate basic Auth passwords for every service and client. No one wants one compromised password compromising everything. This happens all the time and it’s not pretty.
• Don’t ship it around your network for fun. If you have access to AWS secrets, Hashi Vault or Azure Secrets, put it there and check it out as runtime. Otherwise, just put it where it needs to be and don’t try to be clever about it.
• Don’t check passwords into source control. It ends up being another avenue to accidentally share them.

In summary:

• Use basic Auth.
• write the password in plain text in a correctly secured file exactly where it’s needed.
• for the love of all that’s holy, don’t try to use WSSE.
• use HTTPS.

Happy sailing!

Edit: Also, practice replacing the secret, ideally with automation - and preferrably do so every 90 days.

Edit 2: Make that password as long as heck and meaningless. No one needs to memorize this thing. Generate it random, long and meaningless, paste it in two places, and forget about it for 90 days.

Edit 3: Deliver this secret to your end user over the phone (spoken to a human, not a text message). Do so every 90 days. When they complain, ask them if they’re interested in OAuth now.