If you have read our articles on session keys or spend permissions, you already know the problem they solve: an app asks for one scoped, time limited permission instead of a signature for every single action. What those articles did not cover is that several wallets have been building their own version of this idea, in their own way. ERC-7715 is an attempt to standardize the request itself, so a dapp can ask any supporting wallet for a permission using the same method, instead of writing custom code for every wallet it wants to work with.
The one thing ERC-7715 actually defines
ERC-7715 adds a single new method that a dapp can call on a wallet, named wallet_grantPermissions. That is the entire scope of the standard. A dapp sends a request describing what it wants, for example a spending cap on a specific token, a time window, and which account it applies to. The wallet shows the user a confirmation screen. If the user approves, denies, or narrows the request, the wallet replies in a format any ERC-7715 compatible dapp knows how to read.
What the standard deliberately does not define is how the wallet actually enforces that permission once granted. That part is left to each wallet's own implementation. A smart contract wallet might enforce it through a permission module attached to the account, a validator contract, or a signer the wallet already trusts for this purpose. ERC-7715 is only the conversation between the dapp and the wallet, not the mechanism that polices the permission afterward.
Why that split matters
Splitting the request format from the enforcement mechanism is the whole point. Before a shared standard, a session key feature built for one wallet's smart contract architecture had no reason to work the same way on a different wallet's architecture. Every integration was effectively custom. A dapp that wanted to support permission based flows across several wallets had to write separate code paths for each one.
With a shared request format, a dapp can ask for a permission the same way regardless of which compatible wallet the user has connected. The wallet is still free to enforce that permission however fits its own design, through whatever account abstraction setup it uses under the hood. The dapp side gets consistency. The wallet side keeps flexibility.
A companion standard on the contract side
ERC-7715 usually gets mentioned alongside a related draft, ERC-7710, which standardizes the contract side of the same idea: how one contract can formally delegate a specific permission to another account onchain. Where ERC-7715 is the conversation between an app and a wallet's user interface, ERC-7710 is closer to the onchain plumbing that actually carries out a delegated permission once it has been granted. The two are designed to fit together, though a wallet can implement one without necessarily implementing the other.
Where this shows up today
This is still a draft standard, not a finished one, and it is worth being clear about what that means in practice. A draft EIP has not gone through the full Ethereum standards process, and its details can still change before, or instead of, reaching a final state. That said, draft status has not stopped real implementations from shipping around it. Coinbase Smart Wallet built a permissions feature based on the ERC-7715 draft not long after it was proposed, and wallet tooling from other teams has added support for the same request format in their smart account kits.
In practice, this means the underlying idea, a scoped permission with a cap and an expiry, request and response, is becoming more consistent across wallets that choose to adopt it. It does not mean every wallet on Base or anywhere else already speaks this exact format, or that a permission granted in one wallet's interface will look identical in another's. Standardization efforts like this tend to spread gradually, as more wallets and app developers adopt the same method rather than inventing their own.
What this means for you as a user
None of this changes what you should actually check before approving a permission request, which is the same advice from our session keys article: look for a visible spending cap, a visible expiry, and a scope limited to the one app asking for it. ERC-7715 does not make a permission inherently safer. It mainly affects how consistently that request gets presented and handled behind the scenes, and whether the app you are using had to build custom integration work for your specific wallet or could rely on a shared format.
If you mostly use a traditional recovery phrase wallet for straightforward swaps and transfers, standards like this will rarely surface directly, since a plain swap only needs one ordinary signature to begin with. Where it matters is in the newer category of smart contract wallets and the apps built to take advantage of them, where fewer custom integrations generally means permission screens that behave more predictably from one app to the next.
The calm summary
ERC-7715 is a draft standard for one specific handshake: a dapp asking a wallet for a scoped permission through a common method, wallet_grantPermissions. It does not dictate how a wallet enforces that permission once granted, which is why it pairs naturally with the session key and spend permission features already shipping on wallets today. It is still early and not universally adopted, but it points toward a future where permission prompts look and work more alike across different wallets, rather than each one being its own special case.
Sources: MetaMask developer documentation on ERC-7715, Ethereum ERCs repository