TeeAPI

TeeAPI is a secure and privacy-preserving API bridge that allows smart contracts to access external web data in a trustless way—without exposing sensitive information or relying on centralized oracles.

The project leverages Trusted Execution Environments (TEEs) to enable confidential and tamper-proof API calls from any EVM-compatible blockchain (currently deployed on Base Sepolia). Smart contracts can request data from public or private APIs, apply private condition checks, and receive only the verified results—bringing real-world data on-chain while preserving blockchain principles like decentralization, transparency, and security.

TeeAPI is designed to be a developer-friendly, composable infrastructure layer for building next-generation dApps across multiple industries, for example:

• Parametric Insurance: Trigger claims automatically from verifiable external data (e.g. weather, flight delays, earthquakes).
• Prediction Markets: Securely verify outcomes of real-world events (e.g. election results, sports scores).
• DeFi Loans: Privately validate financial info like income or credit score without revealing personal details.
• Climate & IoT: Integrate sensor data to power carbon credits, air quality tracking, or logistics verification.

Core Features

1. Secure REST API Integration Connect smart contracts to any external web API while maintaining end-to-end security and decentralized execution.
2. Flexible Data Privacy Controls Developers have full control over which parts of the request (e.g. URLs, query params, headers) and response (e.g. specific fields) are encrypted and kept private—or made visible on-chain.
3. Confidential Condition Checks Implement private, off-chain logic to verify conditions (e.g. “is delay > 30 minutes?”) inside the TEE. Only the result (true/false) is returned, with sensitive data fully hidden.

For demo, we have implemented a Flight Delay Insurance use case to show how a smart contract can automatically trigger payouts based on real-time flight data without exposing the raw API response. The project provides an example implementation using the TeeAPI service, showcasing encrypted API key usage, while still showing which API endpoint is used (for public verification), conditional logic (is flight landed/delayed) and a clear use case (direct payout instead of a long insurance claiming process).

Some useful links:

• Landing Page: https://teeapi.aifusionlabs.xyz
• GitHub: https://github.com/0xAkuti/TeeApi
• Deployed TeeAPI Oracle (example on Base Sepolia): https://sepolia.basescan.org/address/0xb345d96d8f1ef2fb463a82a15e2a2ea066f003c0
• Example Use Case implementation: https://sepolia.basescan.org/address/0x08B761d3D9300e56CaC0c85A438C9f6aC2e7DCd3
• Interact with our Demo Use Case a flight delay insurance: https://abi.ninja/0x08B761d3D9300e56CaC0c85A438C9f6aC2e7DCd3/84532?methods=initiateClaim
• Phala deployment and attestation: https://40f45b81d72df1a300385dc591eb04007a9fe7d7-8090.dstack-prod5.phala.network/

TeeAPI combines smart contracts with a TEE-secured oracle service to address the challenge of securely integrating off-chain API data with blockchain applications.

For the smart contracts we use Solidity with the Foundry for development workflow (testing, deployment, scripting) and Solady library for gas-efficient contract components.

For the TEE Service Layer we implement in Python with asyncio for the backend service, Web3.py for blockchain interaction (subscribing to events, sending the tx fulfilling the request), eciespy for Ethereum-compatible ECIES encryption, dstack-sdk for TEE attestation and secure key management, FastAPI for the auxiliary API server (health check, get public key, encrypt data), Docker for containerization and deployment.

Key Technical Patterns:

Secure External API Access: The Oracle contract provides a standardized interface for smart contracts to request data from external APIs. Requests are processed in a secure TEE environment, ensuring that API keys and sensitive request data remain protected.

ECIES Encryption with secp256k1: We use Ethereum's native curve with ECIES for encrypting sensitive data. This approach ensures compatibility with existing Ethereum infrastructure while providing strong cryptographic security. We also add a API endpoint in the TEE that allows users to easily encrypt sensitive data to use in their smart contracts securely.

The conditional verification with encrypted comparison values is a little hacky but very useful to compare for example against a bank balance while only getting a true/false back, on-chain you cannot even see the amount it was compared against.