If data is accessible
through an API
Molpha can make it
verifiable on-chain
Verifiable external datafor{ smart contracts }and{ AI agents }
Request threshold-signed data from any API and use it directly inside your smart contract.
Verifiable external datafor{ smart contracts }and{ AI agents }
Request threshold-signed data from any API and use it directly inside your smart contract.
{ Start on testnet }{ Protocol pillars }
Oracle infrastructure for arbitrary data, not just price feeds.
Built for AI & apps.
Native SDKs for applications. MCP for AI agents. Same trust model everywhere.
Any external data
Turn any HTTP API into cryptographically verifiable data.
Three VMs. One signature.
Verify one threshold-signed payload on Solana, any EVM chain, and Starknet. Three VM families. One signing ceremony.
USDC subscriptions
Pay predictable monthly fees in USDC. No oracle token. No governance token.
Native SDKs for applications. MCP for AI agents. Same trust model everywhere.
Turn any API into verifiable data
SDK handles creation, funding, and usage
Complete oracle workflow through MCP
Apps consume verified data on demand
Chain-agnostic signed payloads
USDC-native, predictable subscriptions
Wait for provider support
Vendor decides what data exists
Custom agent integrations
On-chain apps wait for feed updates
Chain-specific oracle setup
Native-token gas and token exposure
{ Solution }
From price feeds to programmable external data.
Molpha is not "better price feeds." It is an SDK-accessible oracle layer for arbitrary external data.
Old way
Molpha way
{ Start on testnet }{ Use Cases }
Where arbitrary data becomes executable
Molpha is not limited to price feeds. Any API-backed signal can become a verified input for smart contracts, agents, markets, and protocols.
AI agents
01/06
Let agents act on verifiable web data.
- Payment status
- Rebalance signal
- Risk lookup
- Delivery confirmation
- Off-chain task completion proof
Why Molpha fits
Molpha MCP allows direct interation with protocol
Prediction markets
02/06
Settle markets with verified outcomes.
- Match result / score
- Election outcomes
- Weather at expiry
- Market close price
- Cancellation flag
Why Molpha fits
Prediction markets need settlement proof, not a permanentl feed.
RWA and finance
03/06
Bring off-chain financial references on-chain.
- Fund NAV
- Proof-of-reserves total
- SOFR / FX reference
- Invoice status
- Custody attestation
Why Molpha fits
RWA workflows rely on statuses, attestations, and custom reference data.
DePIN
04/06
Verify real-world network conditions on-chain.
- Uptime score
- Coverage status
- Outage flag
- Bandwidth usage
- Compute availability
Why Molpha fits
Protocols can verify external network state before execution.
Registries and compliance
05/06
Use external records as contract inputs.
- License validity
- Property status
- KYC / eligibility flag
- Sanctions result
- Title verification
Why Molpha fits
Many workflows require verifiable status checks — not price feeds.
Supply chain and trade finance
06/06
Trigger contracts from real-world logistics events.
- Shipment delivered
- ETA deviation
- Customs cleared
- Warehouse receipt
- Invoice approved / paid
Why Molpha fits
Business events can be verified directly from external APIs.
If data is accessible
through an API
Molpha can make it
verifiable on-chain
{ How Molpha works }
From API to on-chain data in minutes
Create once. Request when needed. Verify anywhere.
01Fund
Activate a USDC subscription on Solana. Agents skip this step entirely — see the agent flow.
02Describe the request
Point at any API with parsing and freshness rules. Feed identity is derived from the request.
03Request signed data
The gateway runs a round; independent nodes fetch, converge, and threshold-sign the value.
04Verify anywhere
One signed payload verifies on Solana, any EVM chain, and Starknet.
01Fund
Activate a USDC subscription on Solana. Agents skip this step entirely — see the agent flow.
02Describe the request
Point at any API with parsing and freshness rules. Feed identity is derived from the request.
03Request signed data
The gateway runs a round; independent nodes fetch, converge, and threshold-sign the value.
04Verify anywhere
One signed payload verifies on Solana, any EVM chain, and Starknet.
{ For developers }
Easy integration in just a few minutes
Copy code into your smart contract and read verified data on-chain.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import {IFeed} from "molpha-oracle/interfaces/IFeed.sol";
import {AggregatorV3Interface} from "./AggregatorV3Interface.sol";
contract ConsumerExample {
IFeed public immutable feed;
constructor(address _feed) {
feed = IFeed(_feed);
}
function getLatest()
external
view
returns (bytes memory value, uint256 timestamp)
{
return feed.getLatest();
}
function getLatestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
)
{
return AggregatorV3Interface(address(feed)).latestRoundData();
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import {IFeed} from "molpha-oracle/interfaces/IFeed.sol";
import {AggregatorV3Interface} from "./AggregatorV3Interface.sol";
contract ConsumerExample {
IFeed public immutable feed;
constructor(address _feed) {
feed = IFeed(_feed);
}
function getLatest()
external
view
returns (bytes memory value, uint256 timestamp)
{
return feed.getLatest();
}
function getLatestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
)
{
return AggregatorV3Interface(address(feed)).latestRoundData();
}
}
{ Secure by design }
Security is not a feature. It’s the oracle.
External data becomes a protocol risk the moment smart contracts rely on it. Molpha delivers cryptographic proof — not infrastructure promises.
Read DocsRotating verifier selection
Verifier sets rotate deterministically between rounds, reducing fixed-node trust.
Threshold-signed data
Selected verifiers independently fetch, compute, and sign the same value.
Bonded verifier nodes
Verifier nodes bond USDC to participate. Provable offenses produce on-chain evidence.
Stateless verification
Verification is a pure view call with no state reads or subscription checks. One signature works across every supported chain.
Signer transparency
Signer participation is embedded directly into every payload.
User-controlled private API keys
API credentials remain encrypted and controlled by the job owner.
Config-bound payloads
The feed identity is derived from the request. Signed payloads cannot be detached from their configuration.
{ Pricing }
Start building on Molpha today
The testnet is live today.
Build, verify, and integrate using free testnet resources before mainnet.
Testnet
Free
20 Testnet USDC included
Faucet access
Testnet environment
Cross-chain verification
MCP integration
{ Philosophy }
Why we’re building Molpha
Blockchains made execution verifiable, but real-world data still lives off-chain.
Accessing it often means relying on closed feeds, custom integrations, or unnecessary infrastructure complexity.
We believe off-chain data should be open, composable, and verifiable by default.
Mission
Make external data a native, verifiable input to on-chain applications.
Vision
A world where smart contracts can safely interact with off-chain systems without depending on closed oracle access.
Goal
Make verified data simple to create, simple to access, and usable across chains.
{ Philosophy }
Why we’re building Molpha
Blockchains made execution verifiable, but real-world data still lives off-chain.
Accessing it often means relying on closed feeds, custom integrations, or unnecessary infrastructure complexity.
We believe off-chain data should be open, composable, and verifiable by default.
Mission
Make external data a native, verifiable input to on-chain applications.
Vision
A world where smart contracts can safely interact with off-chain systems without depending on closed oracle access.
Goal
Make verified data simple to create, simple to access, and usable across chains.
{ Try Molpha }
Create your first verified API job
Start with any API endpoint. Get a signed payload. Verify it on-chain.
No sales calls
No long onboarding
No long-term commitments