A Frame is a set of Open Graph metadata tags added to a standard HTML webpage that instructs a compatible client, like a Farcaster client, to render the page as an interactive, stateful application. This allows users to perform actions—such as minting NFTs, voting in polls, or executing transactions—without ever leaving their social feed. The protocol effectively turns static links into mini-applications, creating a seamless, native experience for on-chain interactions within a social context.
LABS
Glossary
Frames
Frames are interactive, app-like components embedded within social media posts or casts, enabling direct on-chain actions like minting NFTs, tipping, or voting.
Chainscore © 2026
definition
FRAMES
What are Frames?
Frames are a protocol that transforms any webpage into an interactive application directly within social media feeds, primarily on Farcaster, by embedding smart contract interactions.
Technically, a Frame consists of specific HTML <meta> tags in the page's <head> that define its properties: an image, input buttons, and a post URL for processing user actions. When a user interacts with a button, the client sends a signed message to the Frame's server, which returns a new set of metadata to update the Frame's state or trigger an on-chain transaction. This architecture enables complex, multi-step experiences like games or minting flows, all while maintaining user identity and security through cryptographic signatures from their connected wallet.
The primary innovation of Frames is interoperability and discoverability. Any webpage can become a Frame, and any client that supports the protocol can render it, breaking down walled gardens. This has led to viral distribution of applications directly through social posts, as a single cast (post) can contain a fully functional app. Key use cases include token launches, on-chain quizzes, charitable donations, and collaborative art projects, all accessible with a single click from a user's feed.
Frames are intrinsically linked to the Farcaster ecosystem, where they were first introduced and popularized, but the open protocol is designed to be client-agnostic. They represent a significant step toward social finance (SocialFi), embedding DeFi primitives and smart contract functionality into the natural flow of social media. By lowering the friction for on-chain engagement, Frames have become a powerful tool for community building, decentralized marketing, and creating new forms of interactive media on the blockchain.
how-it-works
TECHNICAL OVERVIEW
How Frames Work
A technical breakdown of the Farcaster Frames protocol, explaining its architecture and the mechanics of turning any cast into an interactive application.
A Frame is a standardized, interactive component embedded within a social media post on the Farcaster protocol, enabling developers to build mini-applications that users can engage with directly from their feed without leaving the platform. This is achieved by embedding specific Open Graph meta tags in the HTML of a shared URL, which the Farcaster client (like Warpcast) parses to render a rich, interactive card. The core innovation is the specification of a simple JSON-based API that the Frame uses to communicate user actions—such as button clicks—back to the developer's server, which can then return a new Frame state or an external transaction. This creates a seamless, app-like experience within the social feed itself.
The technical workflow begins when a user posts a cast containing a URL. The Farcaster client fetches this URL and scans its HTML <head> for Frame-specific meta tags (prefixed with fc:frame). These tags define the Frame's initial state: its image, text, and up to four action buttons. Each button has a defined type—like "post" to submit data back to the Frame server, "post_redirect" to navigate to a link, or "mint" to trigger an NFT mint. When a user clicks a button, the client sends a signed HTTP POST request to the developer's server endpoint specified in the fc:frame:post_url tag, including the user's interaction and cryptographic signature for verification.
The developer's server processes this request, validates the signature to confirm the user's Farcaster identity, and executes the requested logic. It then returns a simple JSON response that instructs the client on what to display next. This response can update the Frame in-place with a new image and button set, redirect the user to an external URL, or—critically for web3 interactions—prompt the user to sign and broadcast an on-chain transaction via a transaction payload. This mechanism allows Frames to facilitate actions like token swaps, NFT mints, and voting directly from the social interface, blending social media and decentralized application functionality.
Key to the protocol's security and interoperability is its reliance on established web standards. It uses Open Graph for discovery and rendering, standard HTTP POST for communication, and EIP-712 signatures for user authentication. This design allows any website to become a Frame by simply adding the correct meta tags, and any Farcaster client to render it consistently. The protocol is chain-agnostic, though it has deep integration with Ethereum and its Layer 2 networks for transaction capabilities, enabling developers to build complex, stateful, on-chain experiences that feel native to a social feed.
key-features
FRAMES
Key Features of Frames
Frames are a protocol standard that enables interactive, app-like experiences directly within social media posts, transforming static embeds into dynamic on-chain applications.
01
In-Post Interactivity
Frames allow users to interact with a blockchain application—like minting, voting, or transacting—without leaving their social media feed. This is achieved by embedding interactive buttons and stateful logic within a standard Open Graph image tag.
- User Flow: See a post → Click a button → Sign a transaction → See updated content.
- Example: A post showing an NFT collection where you can mint directly from the timeline.
02
Decentralized State & Logic
The application logic and state for a Frame are hosted on a decentralized server or a blockchain, not a centralized platform. The Frame fetches fresh content and processes actions via its specified Frame Metadata endpoints (fc:frame:post_url).
- Key Components:
image,buttons,post_url,state. - Benefit: Ensures the creator maintains control and the experience is trustless.
03
On-Chain Transaction Integration
Frames can initiate and facilitate on-chain transactions by generating transaction payloads. When a user clicks a button, the Frame can return a Transaction ID for the user to sign in their connected wallet (e.g., Farcaster's embedded wallets).
- Mechanism: Uses the
fc:frame:button:actionproperty with a value oftx. - Use Case: Minting tokens, purchasing items, or executing smart contract functions.
04
Frame Metadata Standard
Frames are defined by a specific set of Open Graph and meta tags embedded in the HTML of a webpage. This standardized schema allows any compatible client (like a Farcaster client) to parse and render the interactive frame.
- Core Tags:
fc:frame,fc:frame:image,fc:frame:button:*. - Portability: The same metadata works across any platform that supports the Frames standard.
05
Dynamic Content Updates
After a user interacts with a Frame, the content can update in real-time to reflect the new state. The Frame server processes the interaction via a POST request and returns a new set of metadata, changing the image, buttons, or text displayed.
- State Management: Can use a signed
stateparameter to maintain context between interactions. - Example: A voting frame that shows updated poll results after your vote.
06
Client-Agnostic Protocol
The Frames specification is an open standard, not proprietary to any single social platform. While pioneered on Farcaster, the protocol is designed to be implemented by any client that can render the required meta tags and handle the post-back interaction flow.
- Ecosystem Goal: Enable composable, portable social applications across the web.
primary-use-cases
FRAMES
Primary Use Cases
Frames transform any webpage into an interactive on-chain application, enabling new forms of social commerce, gaming, and governance directly within existing social feeds and websites.
02
On-Chain Gaming & Quests
Turns static posts into playable, interactive experiences with on-chain rewards. Frames can host simple games, quizzes, or completion proofs.
- Example: A "Guess the Number" game where winners receive tokens or POAPs.
- Key Feature: Maintains state across user interactions, allowing for multi-step quests and progression tracking entirely on-chain.
03
Decentralized Governance & Voting
Facilitates on-chain governance actions directly from social platforms or project websites. Enables seamless voter participation.
- Process: A Frame displays a proposal; users connect their wallet and cast votes via smart contract calls.
- Benefit: Reduces friction in DAO participation by meeting users where they already are, increasing engagement and quorum.
04
Dynamic Content & Authentication
Serves personalized, token-gated content based on a user's on-chain identity and holdings. Acts as a lightweight authentication layer.
- Use Case: A project website uses a Frame to display exclusive content only to NFT holders or token stakers.
- Mechanism: The Frame reads the user's connected wallet address and checks on-chain data via an RPC provider before rendering content.
05
Cross-Platform Bridging & Actions
Creates unified entry points for multi-chain and cross-protocol interactions from a single interface.
- Example: A Frame that lets users bridge assets from Ethereum to Base and then swap them, all in a few clicks.
- Architecture: The Frame's backend can orchestrate calls to multiple smart contracts and bridging protocols, abstracting complexity from the user.
technical-specification
FRAMES
Technical Specification
A technical overview of Frames, a protocol enabling interactive applications to be embedded directly within social media posts on the Farcaster network.
A Frame is a specification that transforms a standard social media post into an interactive, mini-application that can run directly within a Farcaster client, such as a feed or a warpcast. It is built using Open Graph meta tags, allowing developers to define a post's visual appearance, interactive buttons, and the logic for processing user inputs. When a user interacts with a Frame—for example, by clicking a button—the client sends a signed message to the Frame's server, which can update the Frame's state, trigger on-chain transactions, or redirect the user to a new view, all without leaving the social feed.
The core technical components of a Frame are defined in its HTML <meta> tags. Key tags include fc:frame for the protocol version, og:image for the primary visual, and fc:frame:button:* tags to define up to four interactive buttons with actions like post, post_redirect, or mint. The fc:frame:post_url specifies the server endpoint that receives and processes interaction payloads, which contain a signed message verifying the user's identity and their action. This architecture ensures that Frames are client-agnostic; any Farcaster client that supports the protocol can render and interact with them.
Frames enable a wide range of use cases by bridging social media and on-chain activity. Common implementations include permissionless minting of NFTs, in-feed token swaps and bridges, interactive quizzes and games, and decentralized governance voting. The ability to embed a transaction directly into a post, which users can sign with one click via their connected wallet (like a Farcaster Fname), creates a seamless flow from discovery to action. This has made Frames a powerful tool for onboarding and community engagement within the web3 ecosystem.
From a development perspective, creating a Frame involves setting up a web server that returns the appropriate Open Graph HTML or image responses. The server must handle the Frame postback, validating the incoming message signature and returning a new set of meta tags to update the Frame's state. Developers must carefully manage state, often using transaction IDs or user-specific tokens passed via the fc:frame:state parameter, as the protocol itself is stateless. Security considerations are paramount, including signature validation to prevent spoofing and designing flows that are resilient to replay attacks.
The Frame protocol is evolving, with new features and action types being proposed and standardized by the community. This includes support for frame analytics, multi-page frames, and more complex transaction types. As a fundamental primitive of the Farcaster decentralized social graph, Frames represent a significant shift towards composable social experiences, where any developer can build an interactive feature that is instantly available to the entire network's user base without requiring platform approval or a dedicated app.
ecosystem-usage
FRAMES
Ecosystem & Adoption
Frames are a protocol for embedding interactive, on-chain applications directly within social media posts, transforming static content into mini-applications.
01
Core Protocol & Standard
Frames are built on the Farcaster Frames standard, which defines a set of HTML meta tags that allow a standard web page to become an interactive application within a social media client. The protocol specifies how to render buttons, handle user input, and trigger on-chain transactions or state changes. This turns a simple post into a self-contained app without requiring users to leave their feed.
02
On-Chain Interaction
A Frame's primary function is to facilitate direct interaction with smart contracts. Key mechanisms include:
- Transaction Generation: Frames can construct and sign transactions using a user's connected wallet (like Warpcast's native wallet).
- Mint Functions: Enables one-click NFT or token mints from a post.
- State Verification: Frames can read on-chain data to update their UI or gate access, creating dynamic, context-aware experiences.
04
Primary Use Cases & Examples
Frames enable a new category of social finance (SocialFi) and engagement applications:
- Mint-to-Collect: Turning a post's embedded image into a mintable NFT (e.g., early art drops on Farcaster).
- On-Chain Polls & Voting: Creating governance or community sentiment polls that write results to a blockchain.
- Mini-Games & Quizzes: Interactive experiences with on-chain rewards or scorekeeping.
- Cross-Chain Actions: Frames can trigger transactions on multiple networks via protocols like Connext or Socket.
05
Adoption & Network Effects
Adoption is driven by integration into major social clients and developer activity:
- Warpcast Dominance: As the leading Farcaster client, its native support made Frames instantly accessible to its user base.
- Viral Distribution: The shareable, interactive nature of Frames creates inherent network effects, as engaging with a Frame often broadcasts activity back to the social graph.
- Protocol-Agnostic Potential: While pioneered on Farcaster, the Frame standard is designed to be portable to other social platforms.
06
Security & Trust Model
Interacting with Frames introduces unique security considerations:
- User Consent: Each transaction requires explicit user approval via their connected wallet, preventing auto-execution.
- Frame Validation: Clients validate Frame metadata tags to ensure they conform to the standard before rendering interactive elements.
- Server Trust: The Frame's backend server (which generates transaction calldata) must be trusted. Developers are encouraged to use open-source, verifiable logic and reputable hosting.
ARCHITECTURAL COMPARISON
Frames vs. Traditional Web2 Embeds
A technical comparison of Farcaster Frames and conventional web embed technologies.
| Feature | Farcaster Frame | iFrame / Web Embed | Social Media Card (OG) |
|---|---|---|---|
Execution Environment | On-chain smart contract | Host website's origin | Static metadata parser |
User Interaction | In-app, signed transactions | External link navigation | External link navigation |
State & Data Persistence | On-chain or Frame server | Host website session/cookies | None (static) |
Authentication & Identity | Signed Farcaster message (FID) | Separate login (OAuth, wallets) | None |
Monetization & Payments | Native, direct on-chain tx | Third-party processor redirect | Not applicable |
Development Stack | Frame spec, Open Frames, Frames.js | Standard web (HTML, JS, CSS) | Open Graph / Twitter Card tags |
Client-Side Trust Assumption | Verifiable signature | Trust host origin | Trust parser implementation |
Initial Load Time | < 2 sec (cached manifest) | Varies (3rd party resource) | < 1 sec (metadata fetch) |
security-considerations
FRAMES
Security & Trust Considerations
Frames introduce a novel interaction model where external content can trigger on-chain transactions, creating unique security vectors distinct from traditional web3 wallets.
01
Transaction Signing & User Consent
A core security challenge is ensuring clear user consent. Unlike a wallet popup, a Frame's transaction prompt is embedded. Users must verify the transaction details, origin URL, and signing authority before approving. Best practices include displaying a clear summary of the action (e.g., 'Approve 10 USDC to 0xABC...') and using frame metadata to signal trust.
02
Frame Origin Verification
Verifying the source of a Frame is critical for trust. Key mechanisms include:
- Frame Metadata: The
fc:frametags should be served from a verifiable, canonical URL. - Signed Frames: Using cryptographic signatures (e.g., via the Farcaster hub) to prove the Frame's content hasn't been tampered with.
- Domain Reputation: Users and clients may whitelist or warn about frames from unknown domains.
03
Malicious Frame Vectors
Frames can be exploited for phishing and fraud. Common attack vectors include:
- Impersonation: Mimicking legitimate apps or brands to steal approvals.
- Transaction Obfuscation: Hiding malicious actions behind misleading button text.
- State Manipulation: Altering frame state between user clicks to change the intended transaction.
- Drainer Integration: Directly connecting to wallet drainer smart contracts.
04
Client-Side Security (Warpcast, etc.)
The client application (e.g., Warpcast) acts as a security gatekeeper. Its responsibilities include:
- Sandboxing: Isolating frame content from the main app and user's private keys.
- Transaction Simulation: Previewing potential outcomes before signing.
- Warning Systems: Flagging transactions to unknown contracts or with unusual patterns.
- Frame Blacklists: Preventing known malicious frames from loading.
05
Smart Contract & Approval Risks
Frames often request token approvals or direct contract interactions. Users must audit:
- Contract Address: Is it the official, verified contract?
- Approval Amount: Is it unlimited (
type(uint256).max) or a limited, sensible figure? - Function Call: What specific function is being called, and with what parameters? A Frame should make this transparent.
06
Best Practices for Users & Builders
For Users: Always verify the frame URL, review every transaction detail, use hardware wallets, and revoke unused approvals via tools like revoke.cash.
For Builders: Use limited approvals, implement signed frames, provide clear transaction summaries, and host frames on secure, owned domains. Transparency builds trust.
FRAMES
Frequently Asked Questions (FAQ)
Frames are a new standard for creating interactive, app-like experiences directly within social media posts on the Farcaster protocol. This FAQ addresses the most common technical and conceptual questions developers have about building and deploying Frames.
A Frame is an interactive, embeddable application that runs directly within a Farcaster cast, allowing users to take actions like minting NFTs, voting in polls, or playing games without leaving their social feed. Technically, a Frame is a set of Open Graph meta tags embedded in a webpage's HTML. When a user clicks a button in the Frame, their Farcaster client (like Warpcast) sends an HTTP POST request to the Frame's specified server endpoint, which returns a new set of meta tags to update the Frame's display, creating a stateful, multi-step experience.
Key components include:
fc:frame: The root meta tag declaring the Frame version.fc:frame:image: The visual URL displayed in the cast.fc:frame:button: Defines an interactive button and its action type (e.g.,post,post_redirect,mint).fc:frame:post_url: The server endpoint that receives user interactions.
ENQUIRY
Get In Touch
today.
Our experts will offer a free quote and a 30min call to discuss your project.
NDA Protected
Confidentiality24h Response
Time to ValueDirectly to Engineering Team
No Sales Fluff10+
Protocols Shipped
$20M+
TVL Overall