Text | Kaori Edited by | Sleepy.md The first three months of 2026 were very fulfilling for players in the payment sector. On January 11, Google released the UniversalText | Kaori Edited by | Sleepy.md The first three months of 2026 were very fulfilling for players in the payment sector. On January 11, Google released the Universal

Google, Circle, Stripe, and others are all spending money on AI; what will be the joys and sorrows of these payment giants in Q1 2026?

2026/03/20 11:14
8 min read
For feedback or concerns regarding this content, please contact us at crypto.news@mexc.com

Text | Kaori

Edited by | Sleepy.md

Google, Circle, Stripe, and others are all spending money on AI; what will be the joys and sorrows of these payment giants in Q1 2026?

The first three months of 2026 were very fulfilling for players in the payment sector.

On January 11, Google released the Universal Commerce Protocol (UCP) at the Retail Federation of America's annual meeting, attempting to define a common language for AI Agent commerce. That same week, Revolut announced it was among the first EU payment methods to be compatible with Google AP2, PayPal announced its acquisition of merchant directory synchronization company Cymbio, and Mastercard launched its Agent Suite.

In February, Coinbase officially launched Agentic Wallets, allowing AI agents to have their own wallets and autonomously spend, earn, and trade crypto assets. The x402 protocol is deeply integrated with the Google ecosystem and has already processed over 50 million transactions.

March saw a surge of activity. Circle launched Nanopayments, Ramp introduced Agent Cards, Mastercard announced its acquisition of stablecoin infrastructure company BVNK for up to $1.8 billion, and Stripe and Paradigm-incubated Tempo Chain launched their mainnets and simultaneously released the Machine Payments Protocol (MPP).

Within three months, more than a dozen major moves have occurred, some positive and some negative. These events may seem scattered, but they all point to the same structural change: when the cost of machine-to-machine transactions is driven close to zero, the real enemy of payment giants is no longer each other, but zero cost itself.

Key Events Review

In the era of zero cost, there is no winner-takes-all.

Six months ago, we were still debating who should legislate for AI agents. Stripe's ACP, Google's AP2, and Mastercard's Agent Pay were three separate paths, each vying for the right to define the same proposition.

The war is now effectively over, not because one side won, but because everyone realized that a winner-takes-all scenario is not going to happen.

Google's newly launched UCP at the beginning of the year is compatible with all major standards and handles commercial transactions within the search and Gemini ecosystem. Stripe's MPP, launched alongside Tempo, also supports integration with Mastercard and Visa systems, handling self-service payments between machines. Mastercard's Agent Pay handles auditable authorization for high-value transactions.

What started as a struggle for territory has now become a struggle for territory. The tentatively established framework at the agreement level means that the decisive competition has shifted elsewhere.

Here's some data released by Enterprise Onchain: In the past nine months, AI Agents completed 140 million payments, totaling $43 million, with 98.6% using USDC. The average transaction was $0.31, and there are now over 400,000 AI Agents with purchasing power.

Let's break down the meaning of these numbers.

First, transactions were conducted autonomously by machines. 140 million payments were processed without human intervention, bank approval, or credit card verification. Processes that previously required human signatures, reconciliation, and settlement between codes and protocols are now completed autonomously by machines.

Second, the individual transaction amounts are extremely small. An average transaction value of $0.31 means that the vast majority of these payments are micro-payments for API calls, computing power purchases, and data access. Under traditional payment systems, such transactions would be impossible; the minimum transaction fee on any card network would exceed the value of the transaction itself.

Third, the cost approaches zero. With the x402 protocol, payments are directly embedded in HTTP requests. Circle Nanopayments reduces the gas fee for developers' single transactions to zero by aggregating tens of thousands of small payments off-chain and periodically packaging them for on-chain settlement. The on-chain settlement cost is borne by Circle at the batch settlement layer.

Transactions between machines, without checkout pages, payment gateways, or intermediaries, are the source of the problem.

Of course, zero cost currently only applies to the specific scenario of inter-machine micropayments. Stablecoins are not truly free; on the Ethereum mainnet, the gas fee for a small stablecoin transaction can reach over 20% of the transaction amount. Stripe created Tempo precisely to address this issue.

At the consumer payment level, card networks still have advantages that stablecoins cannot replicate: unified consumer protection, consistent user experience, and the flexible routing capabilities of cards as an abstraction layer at the underlying level.

However, this doesn't change the fundamental concern. In scenarios of high-frequency micro-payments between machines, zero cost is already a reality, and this gap is rapidly widening. Deloitte predicts that the global agent market will reach $45 billion by 2030. This is a completely new world of transactions, tearing a huge gap at the edge of traditional payments.

The giants' response: From collecting tolls to building bridges

Faced with the threat of zero costs, traditional payment giants have adopted different strategies, but they share a common underlying logic: since they cannot collect fees in the scenario of inter-machine micro-payments, they should control the bridge between the old and new systems and charge fees there.

Visa's strategy is absorption rather than confrontation. USDC settlement has officially launched in the United States, and crypto-friendly banks such as Cross River Bank and Lead Bank have begun using it. Visa Direct supports stablecoin pre-deposits and direct payments.

In other words, you can use stablecoins, but please use my network. Visa also participated in the development of the MPP, extending the protocol to card payment scenarios—a typical example of joining in if you can't beat them.

Mastercard's $1.8 billion acquisition of BVNK was essentially buying a bridge between fiat currency and stablecoins. BVNK supports fiat-to-stablecoin conversion across all major blockchain networks in over 130 countries, which is the most critical infrastructure for the AI ​​Agent payment era.

Mastercard's Chief Product Officer, Jorn Lambert, responded directly to the claim that stablecoins threaten the card business: the card business is fine, and the acquisition is for expansion into new areas such as remittances. However, the deeper logic is that as stablecoin trading volume grows rapidly, controlling the clearing bridge between fiat currency and stablecoins means controlling the lifeline of value flow.

Stripe has the biggest ambitions. It owns its own blockchain Tempo, its own protocol MPP, and Open Issuance, a platform that allows companies to issue their own stablecoins and share reserve yields—this is the ultimate in vertical integration.

The combination of Tempo, MPP, and Open Issuance means that Stripe is no longer just a payment processor; it is becoming an infrastructure operator in the era of AI Agent payments.

PayPal took a different approach. Its acquisition of Cymbio wasn't about controlling the payment pipeline, but rather controlling the distribution of merchant catalogs. Cymbio's core capability is its Store Sync technology, which allows merchants to synchronize their product catalogs across multiple AI shopping surfaces with a single click. This means that small and medium-sized merchants no longer need to adapt to each AI platform individually.

When AI agents replace humans in discovering products, whether merchants' product catalogs can be seen by AI becomes a matter of life and death. PayPal is betting that in the era of Agent Commerce, being discovered by an agent is valuable in itself.

An interesting intermediate state is Ramp Agent Cards, which issue virtual cards to AI agents, still using the Visa card network, but dynamically authorizes each transaction and does not expose real card information. Essentially, this turns corporate spending cards into agent wallets.

Whether this is a continuation of traditional payments or a stopgap measure during the transition period remains unclear. If the mainstream form of machine-to-machine transactions ultimately moves towards a stablecoin-native approach, then Agent Cards may be the last chance for traditional card networks to be needed in the new era.

How to make money in the new era?

There's a question that hasn't been answered directly. On the zero-cost track, the transactions themselves don't incur fees. So, who profits?

Circle's Nanopayments earns revenue from infrastructure service fees, Stripe's Open Issuance earns revenue from reserve funds, and Mastercard, after acquiring BVNK, earns revenue from converting between fiat currency and stablecoins.

All three charging methods share a common characteristic: the charging point has shifted from the transaction itself to the conditions under which the transaction can occur. Essentially, they are closer to infrastructure rent than transaction taxes.

This represents a fundamental shift in business models. For the past fifty years, the moat of payment networks has been the network effect. The more merchants there are, the more consumers are willing to use it; the more consumers there are, the more merchants need to connect. This flywheel profits from the commission rights brought by scale.

In the world of machine-to-machine transactions, this flywheel has failed. Machines only need a stable, programmable, and low-cost settlement layer; whoever can provide that becomes the new infrastructure provider.

The survival of payment giants is not a major issue. The real question is: in an industry that relies on commissions to maintain its power, where does that power go once the commissions lose their meaning?

Market Opportunity
Collector Crypt Logo
Collector Crypt Price(CARDS)
$0.03828
$0.03828$0.03828
+9.24%
USD
Collector Crypt (CARDS) Live Price Chart
Disclaimer: The articles reposted on this site are sourced from public platforms and are provided for informational purposes only. They do not necessarily reflect the views of MEXC. All rights remain with the original authors. If you believe any content infringes on third-party rights, please contact crypto.news@mexc.com for removal. MEXC makes no guarantees regarding the accuracy, completeness, or timeliness of the content and is not responsible for any actions taken based on the information provided. The content does not constitute financial, legal, or other professional advice, nor should it be considered a recommendation or endorsement by MEXC.

You May Also Like

Trump-backed WLFI  launches AgentPay SDK open-source payment toolkit for AI agents

Trump-backed WLFI  launches AgentPay SDK open-source payment toolkit for AI agents

The Trump family has expanded its presence in the crypto community with a major development for artificial intelligence (AI) agents. According to reports, World
Share
Cryptopolitan2026/03/20 19:03
Summarize Any Stock’s Earnings Call in Seconds Using FMP API

Summarize Any Stock’s Earnings Call in Seconds Using FMP API

Turn lengthy earnings call transcripts into one-page insights using the Financial Modeling Prep APIPhoto by Bich Tran Earnings calls are packed with insights. They tell you how a company performed, what management expects in the future, and what analysts are worried about. The challenge is that these transcripts often stretch across dozens of pages, making it tough to separate the key takeaways from the noise. With the right tools, you don’t need to spend hours reading every line. By combining the Financial Modeling Prep (FMP) API with Groq’s lightning-fast LLMs, you can transform any earnings call into a concise summary in seconds. The FMP API provides reliable access to complete transcripts, while Groq handles the heavy lifting of distilling them into clear, actionable highlights. In this article, we’ll build a Python workflow that brings these two together. You’ll see how to fetch transcripts for any stock, prepare the text, and instantly generate a one-page summary. Whether you’re tracking Apple, NVIDIA, or your favorite growth stock, the process works the same — fast, accurate, and ready whenever you are. Fetching Earnings Transcripts with FMP API The first step is to pull the raw transcript data. FMP makes this simple with dedicated endpoints for earnings calls. If you want the latest transcripts across the market, you can use the stable endpoint /stable/earning-call-transcript-latest. For a specific stock, the v3 endpoint lets you request transcripts by symbol, quarter, and year using the pattern: https://financialmodelingprep.com/api/v3/earning_call_transcript/{symbol}?quarter={q}&year={y}&apikey=YOUR_API_KEY here’s how you can fetch NVIDIA’s transcript for a given quarter: import requestsAPI_KEY = "your_api_key"symbol = "NVDA"quarter = 2year = 2024url = f"https://financialmodelingprep.com/api/v3/earning_call_transcript/{symbol}?quarter={quarter}&year={year}&apikey={API_KEY}"response = requests.get(url)data = response.json()# Inspect the keysprint(data.keys())# Access transcript contentif "content" in data[0]: transcript_text = data[0]["content"] print(transcript_text[:500]) # preview first 500 characters The response typically includes details like the company symbol, quarter, year, and the full transcript text. If you aren’t sure which quarter to query, the “latest transcripts” endpoint is the quickest way to always stay up to date. Cleaning and Preparing Transcript Data Raw transcripts from the API often include long paragraphs, speaker tags, and formatting artifacts. Before sending them to an LLM, it helps to organize the text into a cleaner structure. Most transcripts follow a pattern: prepared remarks from executives first, followed by a Q&A session with analysts. Separating these sections gives better control when prompting the model. In Python, you can parse the transcript and strip out unnecessary characters. A simple way is to split by markers such as “Operator” or “Question-and-Answer.” Once separated, you can create two blocks — Prepared Remarks and Q&A — that will later be summarized independently. This ensures the model handles each section within context and avoids missing important details. Here’s a small example of how you might start preparing the data: import re# Example: using the transcript_text we fetched earliertext = transcript_text# Remove extra spaces and line breaksclean_text = re.sub(r'\s+', ' ', text).strip()# Split sections (this is a heuristic; real-world transcripts vary slightly)if "Question-and-Answer" in clean_text: prepared, qna = clean_text.split("Question-and-Answer", 1)else: prepared, qna = clean_text, ""print("Prepared Remarks Preview:\n", prepared[:500])print("\nQ&A Preview:\n", qna[:500]) With the transcript cleaned and divided, you’re ready to feed it into Groq’s LLM. Chunking may be necessary if the text is very long. A good approach is to break it into segments of a few thousand tokens, summarize each part, and then merge the summaries in a final pass. Summarizing with Groq LLM Now that the transcript is clean and split into Prepared Remarks and Q&A, we’ll use Groq to generate a crisp one-pager. The idea is simple: summarize each section separately (for focus and accuracy), then synthesize a final brief. Prompt design (concise and factual) Use a short, repeatable template that pushes for neutral, investor-ready language: You are an equity research analyst. Summarize the following earnings call sectionfor {symbol} ({quarter} {year}). Be factual and concise.Return:1) TL;DR (3–5 bullets)2) Results vs. guidance (what improved/worsened)3) Forward outlook (specific statements)4) Risks / watch-outs5) Q&A takeaways (if present)Text:<<<{section_text}>>> Python: calling Groq and getting a clean summary Groq provides an OpenAI-compatible API. Set your GROQ_API_KEY and pick a fast, high-quality model (e.g., a Llama-3.1 70B variant). We’ll write a helper to summarize any text block, then run it for both sections and merge. import osimport textwrapimport requestsGROQ_API_KEY = os.environ.get("GROQ_API_KEY") or "your_groq_api_key"GROQ_BASE_URL = "https://api.groq.com/openai/v1" # OpenAI-compatibleMODEL = "llama-3.1-70b" # choose your preferred Groq modeldef call_groq(prompt, temperature=0.2, max_tokens=1200): url = f"{GROQ_BASE_URL}/chat/completions" headers = { "Authorization": f"Bearer {GROQ_API_KEY}", "Content-Type": "application/json", } payload = { "model": MODEL, "messages": [ {"role": "system", "content": "You are a precise, neutral equity research analyst."}, {"role": "user", "content": prompt}, ], "temperature": temperature, "max_tokens": max_tokens, } r = requests.post(url, headers=headers, json=payload, timeout=60) r.raise_for_status() return r.json()["choices"][0]["message"]["content"].strip()def build_prompt(section_text, symbol, quarter, year): template = """ You are an equity research analyst. Summarize the following earnings call section for {symbol} ({quarter} {year}). Be factual and concise. Return: 1) TL;DR (3–5 bullets) 2) Results vs. guidance (what improved/worsened) 3) Forward outlook (specific statements) 4) Risks / watch-outs 5) Q&A takeaways (if present) Text: <<< {section_text} >>> """ return textwrap.dedent(template).format( symbol=symbol, quarter=quarter, year=year, section_text=section_text )def summarize_section(section_text, symbol="NVDA", quarter="Q2", year="2024"): if not section_text or section_text.strip() == "": return "(No content found for this section.)" prompt = build_prompt(section_text, symbol, quarter, year) return call_groq(prompt)# Example usage with the cleaned splits from Section 3prepared_summary = summarize_section(prepared, symbol="NVDA", quarter="Q2", year="2024")qna_summary = summarize_section(qna, symbol="NVDA", quarter="Q2", year="2024")final_one_pager = f"""# {symbol} Earnings One-Pager — {quarter} {year}## Prepared Remarks — Key Points{prepared_summary}## Q&A Highlights{qna_summary}""".strip()print(final_one_pager[:1200]) # preview Tips that keep quality high: Keep temperature low (≈0.2) for factual tone. If a section is extremely long, chunk at ~5–8k tokens, summarize each chunk with the same prompt, then ask the model to merge chunk summaries into one section summary before producing the final one-pager. If you also fetched headline numbers (EPS/revenue, guidance) earlier, prepend them to the prompt as brief context to help the model anchor on the right outcomes. Building the End-to-End Pipeline At this point, we have all the building blocks: the FMP API to fetch transcripts, a cleaning step to structure the data, and Groq LLM to generate concise summaries. The final step is to connect everything into a single workflow that can take any ticker and return a one-page earnings call summary. The flow looks like this: Input a stock ticker (for example, NVDA). Use FMP to fetch the latest transcript. Clean and split the text into Prepared Remarks and Q&A. Send each section to Groq for summarization. Merge the outputs into a neatly formatted earnings one-pager. Here’s how it comes together in Python: def summarize_earnings_call(symbol, quarter, year, api_key, groq_key): # Step 1: Fetch transcript from FMP url = f"https://financialmodelingprep.com/api/v3/earning_call_transcript/{symbol}?quarter={quarter}&year={year}&apikey={api_key}" resp = requests.get(url) resp.raise_for_status() data = resp.json() if not data or "content" not in data[0]: return f"No transcript found for {symbol} {quarter} {year}" text = data[0]["content"] # Step 2: Clean and split clean_text = re.sub(r'\s+', ' ', text).strip() if "Question-and-Answer" in clean_text: prepared, qna = clean_text.split("Question-and-Answer", 1) else: prepared, qna = clean_text, "" # Step 3: Summarize with Groq prepared_summary = summarize_section(prepared, symbol, quarter, year) qna_summary = summarize_section(qna, symbol, quarter, year) # Step 4: Merge into final one-pager return f"""# {symbol} Earnings One-Pager — {quarter} {year}## Prepared Remarks{prepared_summary}## Q&A Highlights{qna_summary}""".strip()# Example runprint(summarize_earnings_call("NVDA", 2, 2024, API_KEY, GROQ_API_KEY)) With this setup, generating a summary becomes as simple as calling one function with a ticker and date. You can run it inside a notebook, integrate it into a research workflow, or even schedule it to trigger after each new earnings release. Free Stock Market API and Financial Statements API... Conclusion Earnings calls no longer need to feel overwhelming. With the Financial Modeling Prep API, you can instantly access any company’s transcript, and with Groq LLM, you can turn that raw text into a sharp, actionable summary in seconds. This pipeline saves hours of reading and ensures you never miss the key results, guidance, or risks hidden in lengthy remarks. Whether you track tech giants like NVIDIA or smaller growth stocks, the process is the same — fast, reliable, and powered by the flexibility of FMP’s data. Summarize Any Stock’s Earnings Call in Seconds Using FMP API was originally published in Coinmonks on Medium, where people are continuing the conversation by highlighting and responding to this story
Share
Medium2025/09/18 14:40
Tom Lee Declares That Ethereum Has Bottomed Out

Tom Lee Declares That Ethereum Has Bottomed Out

Experienced analyst Tom Lee conducted an in-depth analysis of the Ethereum price. Here are some of the highlights from Lee's findings. Continue Reading: Tom Lee
Share
Bitcoinsistemi2026/03/20 19:05