# murlprotocol

## Vision - The Internet Is Not Free

You pay for your computer or mobile phone. You pay for your data plan provider. You pay for your electricity. In order to get online and use the internet, you already need to pay a lot. The internet isn't free.

It's an idea that has bootstrapped the internet into what it is today. Most likely it has accelerated the adoption of the internet by a lot, because people already had computers and a phone carrier that could also provide internet access. However, nowadays, there is little benefit to the fact that the internet is supposedly 'free' and there is still no good payment protocol embedded into browsers.

The disadvantages are obvious: we invented business models addict users, fill websites with advertisements everywhere, and we end up having subscriptions for everything, even if we don't use the service.

The dawn of AI Agents poses an opportunity though. As the interface with computers is changing we have a window to also change the way we pay.

With MURL Protocol we are introducing a new way to pay for using tools and access information on the internet; through invisible micropayments that you don't even notice when you're using these tools - the agent can handle them for you, and ensure you don't pay too much.

This way, values are aligned, and you fairly pay more the more you make use of a service.

I believe in a world where there are no unfair lock-in subscription models needed and where you fairly pay for what you use, nothing more.

## Introducing MURL Protocol - Anonymous Micropayments

It could allow users to connect their credit (e.g. via Stripe with automatic top-up) in order to create secret links that give direct access to funds. This can then be used for agents to verify a user is able to pay and then to retrieve the required funds after doing a certain action successfully. The great part about it, is that a user wouldn't need to provide the platform with any identity. As long as he passes the platform a "MURL" ™️ it would be OK to execute the request.

Specification:

1. `GET /deposit?amount=AMOUNT[&redirectUrl=URL]`: redirects (302) to stripe so human user can deposit funds or link a payment method to MURL Protocol to have a balance there. Amount is always in USD. amount includes stripes fee and an additional MURL transaction fee.
2. `POST /new/{budget}` (Authorized with bearer access token) -> `https://murlprotocol.com/murl/{murlId}`: User (or any api/agent that needs funds to give) can create a new MURL with a certain budget (budget is always in USD as specified in https://docs.stripe.com/currencies)
3. `GET /murl/{murlId}`: MURL path. returns budget, validity, and other information
4. `GET /murl/{murlId}?amount={amount}&address={address}&description={description}&transactionId={id}`: MURL path. Agent can request payment to an address that, if possible, will be carried out. When requesting this URL again, the payment amount will be overwritten. The MURL is only supposed to be used for 1 purpose, so the agent doesn't need to know the user. The payout will only happen after a certain period has passed to ensure overwrites can happen.

MURL Protocol would be a trusted provider that ensures timely pay-outs to all adresses by accumulating all payments over a period.

If such a service existed, it could facilitate much more easy micropayments.

**Q: Can I theoretically make this?**

Everything is possible using [stripe connect](https://docs.stripe.com/connect/payouts-connected-accounts)

At a later stage we can facilitate direct payouts to crypto, paypal, IBAN, or any other payment method. However, to avoid legal slur, it'd be best to do things via Stripe. This makes it required for any user and any agent to have an account at MURL Protocol in order for this to work. In practice, this means, to use MURL Protocol, the agent needs a MURL address, which can be public.

It's a huge advantage as it nicely decouples payments from any worker. The only thing required is for the worker to accept a MURL as header or as argument, in order to do a certain payment. Verifying that would require a single simple API call (GET that URL).

The idea of MURL Protocol could be a standard that allows anyone to start a MURL service with different implementations. The standard would be passing `X-MURL` header to any request to offer a budget to a worker.

I could start building this just around [stripe connect](https://docs.stripe.com/connect/payouts-connected-accounts), but anyone could technically create a MURL implementation. This is the reason the origin is built-in to the API spec. The only thing needed to make this federated would be an independent service that tells the trustworthyness (and maybe ethics) of a MURL, a MURL validator, or so to speak, a MURL tastery.

Anyone could use this concept and create a new decentralised micropayment service. I may just make it possible to do payments to any Stripe account, but, for example, a bank could make it possible to do payouts to any IBAN, or a crypto service could make it possible to do payouts to any crypto address. In the end, people could use each others MURL services to make things more capable and decentralised.