canonical: https://jentic.com/apis/apidapp.com/apidapp

# ApiDapp

Jentic publishes the only available OpenAPI specification for ApiDapp, keeping it validated and agent-ready. The ApiDapp API exposes Ethereum blockchain data and wallet operations over a REST interface. It reads blocks, transactions, transaction receipts, smart contracts, and ERC20 token details, and it can create wallets and send payments from managed accounts. Operations that touch account or contract state authenticate with an API key.

## For AI agents

Lets an AI agent read Ethereum on-chain data, inspect ERC20 tokens and contracts, and create wallets and transactions through a REST interface.

## Scope

Does not provide market prices, portfolio analytics, or non-Ethereum chains; use it to read Ethereum on-chain data and manage wallets and transactions only.

## Capabilities

- Read Ethereum blocks, transactions, and transaction receipts
- Look up ERC20 token details by contract address
- Inspect smart contracts and read their state
- Create and manage Ethereum wallets and their accounts
- Submit transactions and payments from managed accounts
- Check node and blockchain status

## Use cases

### Read Ethereum on-chain data for an app

Apps that surface blockchain activity need reliable reads of blocks, transactions, and receipts. The ApiDapp API returns this on-chain data over REST, so an integration can confirm whether a transaction was mined, read its receipt, and walk the transactions inside a block without running a node.

Example prompt: Given a transaction hash, read the transaction and its receipt and report whether it succeeded.

### Manage wallets and send payments

Products that hold value on Ethereum need to create wallets and move funds. The API creates wallets and accounts and submits transactions and payments from them, letting an integration provision a user wallet and send a payment through one service.

Example prompt: Create a wallet account and submit a payment of a given amount from it.

### Work with ERC20 tokens and contracts

Token-aware applications need details about ERC20 contracts and other deployed contracts. The API reads ERC20 token information by contract address and inspects contract state, so an integration can display token metadata and read on-chain contract data.

Example prompt: Read the ERC20 token details for a given contract address and return its metadata.

### Let an agent query and act on Ethereum

An AI agent that works with Ethereum can read chain data and act on it through ApiDapp. It looks up transactions and tokens, provisions wallets, and submits payments. Through Jentic the agent discovers these operations by intent and runs them under the integration's own credentials.

Example prompt: Given a token contract address, read its details and report the token to the user.

## Key endpoints

| Method | Path | Description |
| --- | --- | --- |
| GET | `/blockchain` | Get blockchain status |
| GET | `/block/{id}` | Get a block by number or hash |
| GET | `/transaction/{hash}` | Get a transaction by hash |
| GET | `/transaction/{hash}/receipt` | Get a transaction receipt |
| POST | `/wallet` | Create a wallet |
| POST | `/transaction` | Submit a transaction |
| GET | `/erc20/{address}` | Get ERC20 token details by contract address |
| POST | `/contract` | Register a smart contract |

## Key resources

- **Blocks** — Read blocks by number or hash and the transactions they contain
- **Transactions** — Read transactions and receipts and submit new transactions
- **Wallets** — Create wallets and accounts and send payments from them
- **Contracts** — Inspect smart contracts and read their state
- **ERC20** — Read ERC20 token details by contract address

## Why Jentic

- **Setup:** Talking to Ethereum directly means running a node or wiring an RPC provider, tracking the API key, and handling wallet and transaction encoding yourself. With Jentic you install once, import ApiDapp from the Directory, and store the API key a single time.
- **Permission scoping:** Running Jentic in your own instance, you decide which ApiDapp operations the agent may call, so you can allow reads on blocks and transactions while blocking wallet creation or payments. Access is granted per operation.
- **Credential handling:** Your ApiDapp API key is held encrypted by your own Jentic One instance and injected only when an operation runs, so it never appears in the agent's prompt, logs, or context.
- **Discovery method:** Agents find ApiDapp through Jentic's intent search: a request like read a transaction by hash or create a wallet resolves to the right operation with inputs and auth prepared.

## Related APIs

- **Alchemy** — Provides Ethereum node infrastructure and enhanced APIs at scale.
- **CoinAPI** — Supplies market prices and trading data across crypto exchanges.
- **CoinMarketCap** — Reports market capitalization and price rankings for crypto assets.

## FAQ

### Is there an MCP server for the ApiDapp API?

You do not need a dedicated MCP server. Through Jentic your self-hosted agent can call ApiDapp operations directly by intent, so you connect the API without maintaining separate MCP tooling.

### Can I restrict what my agent is allowed to do with ApiDapp?

Yes. Because you run Jentic yourself, you choose which ApiDapp operations your agent can call, so you can allow reads of blocks and transactions while withholding wallet creation or payments. Scoping is applied per operation.

### What authentication does the ApiDapp API use?

ApiDapp authenticates with an API key sent in the `X-Api-Key` header. Read-only endpoints such as the version and ERC20 lookups need no key, while account, contract, and transaction operations do. Jentic injects the key from your stored credential when a call runs.

### Does ApiDapp support chains other than Ethereum?

This specification serves Ethereum data and wallet operations. Market pricing and multi-chain coverage are not part of these endpoints, so pair ApiDapp with a market-data service when you need prices.

### Why is there no official OpenAPI spec for ApiDapp?

ApiDapp does not publish its own machine-readable OpenAPI definition, so Jentic generated this specification from the service and keeps it validated so agents can call the API reliably.

### How does an agent discover ApiDapp operations in Jentic?

The agent searches Jentic by intent, such as reading a transaction by hash or creating a wallet, and Jentic returns the matching ApiDapp operations ready to run under your credentials.