Build With Trustless Compute on a Decentralized Cloud
Deploy backend logic, off-chain computation, and automation on a decentralized network of independent providers. No centralized servers. No blind trust. Verifiable execution by design.
No credit card. No servers to manage. Wallet-based access.
Why Choose Acurast
Trustless execution
Tasks are cryptographically signed and verifiable
Confidential by design
Providers never access raw secrets or sensitive payloads
Decentralized compute
Execution happens across independent devices
Pay per execution
No idle infrastructure, no long-running instances
Composable with Web3
Built to work with smart contracts, oracles, and on-chain logic
Serverless by default
Zero infrastructure overhead – deploy code, not servers
What You Can Build
AI & CONFIDENTIAL COMPUTE
What You Can Build:
- Confidential LLM inference (run GPT-class models without cloud provider access)
- Privacy-preserving AI for healthcare, finance, or legal industries
- Federated learning systems with distributed trust
- I agents requiring unstoppable, censorship-resistant infrastructure
- Secure database integrations with confidential analytics
Example Use Cases
Healthcare AI diagnostics (HIPAA-compliant), financial fraud detection, legal document analysis, enterprise data processing without cloud exposure.
DeFi & BLOCKCHAIN INFRASTRUCTURE
What You Can Build:
- Decentralized price oracles (push/pull data feeds for DeFi protocols)
- Cross-chain asset bridges with confidential execution
- On-chain automation (liquidations, yield harvesting, rebalancing)
- MEV-resistant trading infrastructure and sequencing
- Crypto trading bots with confidential strategies
- Cross-chain Bitcoin applications (like xcBTC)
Example Use Cases
Multi-chain price feeds, automated DeFi strategies, cross-chain liquidity management, wrapped Bitcoin solutions, MEV protection services.
WEB3 APPLICATIONS & SERVICES
What You Can Build:
- Decentralized backends-as-a-service (serverless APIs)
- Confidential web scraping and data collection
- Blockchain indexers and data aggregators
- Decentralized VPN and proxy networks (ethical, GDPR-compliant)
- zkProof generation services
- Telegram bots, social media monitoring, automation tools
Example Use Cases
Serverless web backends, residential proxy networks, data indexing services, automated social media tools, decentralized hosting platforms.
Designed for Developers, Not DevOps
You write code. Acurast handles decentralized execution and verification.
No infrastructure to manage. No servers to babysit.
Developer experience
Simple task-based execution model
Deterministic and verifiable results
SDKs and APIs built for automation
Wallet-based authentication
Works with existing Web3 tooling
You stay focused on logic, not infrastructure.
Execution Environments
Choose the runtime that fits your workload. More environments are continuously added.
JavaScript (V8)
Best for automation, off-chain logic, and backend services
Status Production ready
Node.js
Ideal for APIs, integrations, and complex workflows
Status Production ready
Python VM
Optimized for data processing and AI workloads
Status Coming soon
PyTorch and TensorFlow support for inference tasks
Status Planned
Docker
Status Coming soon
Works Across the Web3 Ecosystem
Acurast integrates natively with major blockchain ecosystems and execution models.
Supported networks
Protocol compatibility
EVM
Dedicated Layer 1
Polkadot pallets
WebAssembly
Wallet-Native Access
No accounts. No passwords. No proprietary authentication.
Frequently Asked Questions
Below are the most frequently asked questions.
How do I deploy my first app?
Install the Acurast CLI with npm install -g @acurast/cli, run acurast init to generate your acurast.json config and .env file, bundle your project into a single JS file, then run acurast deploy. The CLI handles IPFS upload, on-chain registration, and processor matching automatically.
What runtime do processors use?
Processors run Node.js v24.5. Your app needs to be bundled into a single JavaScript file (e.g. via webpack) or make sure all dependencies are located in the dist folder (node_modules will not be deployed)..
Can I test my code on a live processor before committing?
Yes. The CLI’s acurast live command lets you run your code in a live environment on a remote processor using the same configuration from your acurast.json — useful for validating behavior before a full deployment.
How do I handle API keys and secrets?
Add sensitive values to your .env file and list them in the includeEnvironmentVariables array in acurast.json. They’re encrypted during deployment and only decrypted inside the processor’s Trusted Execution Environment. Not even the device owner can access them. In your code, access them via _STD_.env[“MY_KEY”].
What APIs are available inside the execution environment?
The runtime exposes a _STD_ object with methods for HTTP requests (httpGET, httpPOST), WebSocket connections (_STD_.ws), cryptographic signing and encryption (secp256k1, secp256r1, ed25519), secure random generation, and environment variable access. You can also make outbound HTTP calls and interact with external APIs directly. For detailed information, read our docs
Can my deployment push results on-chain?
Yes. The runtime includes native fulfillment methods for multiple ecosystems — you can push outputs to EVM chains, Substrate-based chains, or Tezos smart contracts directly from your deployment script. The processor settles gas fees on the destination chain using funds you lock upfront.
What's the difference between one-time and interval deployments?
One-time deployments execute once for a defined duration. Interval deployments repeat at a set frequency (e.g. every minute, hourly). Each execution is a discrete, verifiable unit. You configure this in acurast.json under the execution field.
What are On-Demand Deployments?
On-Demand deployments open a persistent WebSocket connection to the Acurast WebSocket service, allowing your dApp to send messages to a running processor in real-time. Useful for interactive use cases where you need to trigger compute from a frontend or smart contract. Integrate with the Acurast TypeScript SDK on the client side.
How does processor matching work?
After you deploy, the Acurast Matcher matches your deployment to available processors based on your configuration — including device attestation requirements, minimum reputation score, and processor whitelists. Processors acknowledge the assignment, and execution begins at the scheduled start time.
Can I run multiple processors for redundancy?
Yes. Set the numberOfReplicas parameter in your acurast.json to assign multiple processors to the same deployment. Devices can go offline, your solution should account for that.
Can I update a running deployment?
If you created the deployment with “mutability”: “Mutable”, you can update the script via acurast deployments update script <deployment-id> <script-ipfs>. You can also update environment variables between interval executions using acurast deployments <id> -e.
What kind of security does "confidential compute" actually provide?
Acurast processors use dedicated hardware coprocessors (e.g. Google’s Titan M2 chip) as Trusted Execution Environments, not just software enclaves on the main application processor. Your code and data are isolated so even the device owner cannot access them during execution. Attestation proofs verify the integrity of the execution environment.
Can I run an LLM on Acurast?
Yes. Acurast includes a module for running LLMs. Most models from Hugging Face in GGUF format are supported. Check the LLM deployment guide in the docs for a step-by-step walkthrough.
Which blockchains can I deliver results to?
Acurast supports native fulfillment to EVM chains (Ethereum, Arbitrum, Optimism, Base, etc.), Substrate chains (Polkadot pallets), Tezos, and more. The protocol compatibility includes EVM, Dedicated Layer 1, Polkadot pallets, and WebAssembly. Acurast integration list