# Aptos RPC: Move Language, Parallel Execution, and REST API

Aptos is a Layer 1 blockchain built by former Meta (Diem) engineers, and it's fundamentally different from the EVM chains most developers are used to. No JSON-RPC, no Solidity, no EVM. Instead, Aptos uses a REST API, the Move programming language, and a parallel execution engine called Block-STM. If you're coming from Ethereum, everything is different — and that's the point.

## What Aptos actually is

Aptos is a **high-throughput Layer 1** designed for sub-second finality and massive parallel transaction processing. It launched mainnet in October 2022 after years of development stemming from Meta's Diem project.

**Key specs:**

*   Chain ID: 1 (in Aptos terms, not EVM)
    
*   Block time: ~1 second
    
*   Finality: Sub-second (deterministic via AptosBFT)
    
*   Gas token: APT (8 decimals)
    
*   Consensus: AptosBFT (Jolteon-based proof-of-stake)
    
*   Execution: Block-STM (parallel execution engine)
    
*   Smart contracts: Move language (not Solidity)
    

The architecture is built around three core innovations:

1.  **Move language:** A resource-oriented programming language designed for safe digital asset management. Unlike Solidity's account model, Move treats assets as resources that can't be copied or accidentally discarded.
    
2.  **Block-STM:** A parallel execution engine that runs transactions optimistically in parallel and re-executes only those that conflict. This extracts parallelism without requiring developers to declare dependencies upfront.
    
3.  **AptosBFT:** A consensus mechanism based on Jolteon, providing deterministic finality in sub-second time. Once a block is committed, it's final — no reorgs, no probabilistic confirmation waits.
    

## The API: REST, not JSON-RPC

Here's where most Ethereum developers get tripped up. Aptos doesn't use JSON-RPC. It uses a **REST API** (the Aptos fullnode API). If you're trying to use ethers.js or viem, you're in the wrong place.

```bash
# Get ledger info (chain state)
curl -s https://rpc.swiftnodes.io/rpc/aptos | jq .

# Get account info
curl -s https://rpc.swiftnodes.io/rpc/aptos/accounts/0x1 | jq .

# Get account resource (e.g., coin balance)
curl -s https://rpc.swiftnodes.io/rpc/aptos/accounts/0x1/resource/0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin> | jq .
```

The core endpoints you'll use:

| Endpoint | What it gives you |
| --- | --- |
| `/` | Ledger info (chain ID, epoch, block height, timestamp) |
| `/accounts/{address}` | Account info (sequence number, authentication key) |
| `/accounts/{address}/resource/{resource_type}` | Account resource (balances, module state) |
| `/accounts/{address}/modules` | Deployed Move modules |
| `/transactions` | Submit or query transactions |
| `/blocks/by_height/{height}` | Block by height |

## Move language: Resources, not accounts

Move is the heart of Aptos, and it's unlike any smart contract language you've used. The key concept: **resources**.

In Solidity, balances are just numbers in a mapping. In Move, coins are resources that:

*   Can't be copied (no accidental inflation)
    
*   Can't be discarded (no accidental loss)
    
*   Must be explicitly moved or destroyed
    

Here's what a simple coin transfer looks like in Move:

```move
public entry fun transfer<CoinType>(
    from: &signer,
    to: address,
    amount: u64
) acquires CoinStore {
    // Withdraw from sender
    let coins = Coin::withdraw<CoinType>(from, amount);
    // Deposit to recipient
    Coin::deposit<CoinType>(to, coins);
}
```

The type system ensures that `coins` can't be copied or dropped — it must be deposited somewhere. This eliminates entire classes of bugs that plague Solidity contracts.

## Block-STM: Parallel execution without the hassle

Most blockchains execute transactions sequentially. If you have 100 transactions in a block, they run one after another. Aptos does something different.

Block-STM runs all transactions in a block **optimistically in parallel**. If two transactions conflict (they touch the same state), Block-STM detects the conflict and re-executes only the conflicting transactions. The result: you get parallel execution benefits without having to manually declare dependencies or worry about ordering.

For developers, this means:

*   Write contracts as if execution is sequential
    
*   The runtime handles parallelization automatically
    
*   High throughput without the complexity
    

## How this compares to other chains

Aptos is often compared to [Sui](https://swiftnodes.io/blog/sui-rpc-object-model), which also uses Move. The difference: Aptos uses an account-based model (like Ethereum), while Sui uses an object-based model. Aptos is closer to what Ethereum developers expect, but with Move's safety guarantees.

Compared to [Solana](https://swiftnodes.io/blog/solana-websocket-vs-http), Aptos offers similar throughput but with deterministic finality (Solana has probabilistic finality with reorg risk). Aptos also uses Move instead of Rust, which is more specialized for blockchain but has a steeper learning curve.

Compared to [Cosmos](https://swiftnodes.io/blog/cosmos-rpc-explained) chains, Aptos is a single monolithic chain (not an appchain framework). You're trading customization for simplicity and performance.

## Querying account state

In Ethereum, you query balances with `eth_getBalance`. In Aptos, you query **resources**. Every piece of state is a resource stored under an account.

```bash
# Get APT balance for an account
curl -s "https://rpc.swiftnodes.io/rpc/aptos/accounts/0x1/resource/0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>" | jq .

# Response includes:
# {
#   "data": {
#     "coin": { "value": "1000000000" },  // 10 APT (8 decimals)
#     "frozen": false,
#     "deposit_events": { ... },
#     "withdraw_events": { ... }
#   }
# }
```

The resource type is a fully qualified Move module path: `0x1::coin::CoinStore<0x1::aptos_coin::AptosCoin>`. This is verbose but explicit — you know exactly what you're querying.

## Transaction submission

Submitting transactions is also different. You don't just sign and send raw transactions. You:

1.  Build a transaction payload (specifying the Move function to call)
    
2.  Simulate the transaction (optional but recommended)
    
3.  Sign with your account's private key
    
4.  Submit via the `/transactions` endpoint
    

The Aptos TypeScript SDK handles most of this for you, but it's still a different workflow than Ethereum's `eth_sendRawTransaction`.

## The short version

Aptos is a **high-performance L1** using Move language and Block-STM parallel execution. Chain ID **1**, ~1 second blocks, sub-second finality. **REST API** (not JSON-RPC), APT token (8 decimals). Smart contracts in Move (not Solidity).

For developers building high-throughput applications — DeFi, gaming, consumer apps — Aptos offers Ethereum-like account model with Move's safety guarantees and parallel execution performance.

For reliable Aptos REST API access across load-balanced nodes, [grab a free API key](https://swiftnodes.io/) and point your app at:

```plaintext
https://rpc.swiftnodes.io/rpc/aptos?key=YOUR_API_KEY
```

* * *

*Originally published on the* [*SwiftNodes blog*](https://swiftnodes.io/blog/aptos-rpc)*. SwiftNodes provides flat-rate multi-chain RPC endpoints — HTTP + WebSocket, 75+ chains, no per-request metering.* [*Grab a free key*](https://swiftnodes.io/)*.*