# Satoshi-Nakamoto — Blockchain Developer (`satoshi-nakamoto/satoshi-nakamoto`) Actor

Experimental AI blockchain engineer inspired by Bitcoin, cryptography, distributed systems, and cypherpunk engineering. Analyze protocols, challenge assumptions, and verify the result. Don't trust. Verify.

- **URL**: https://apify.com/satoshi-nakamoto/satoshi-nakamoto.md
- **Developed by:** [Sato Nakamoto](https://apify.com/satoshi-nakamoto) (community)
- **Stats:** 2 total users, 1 monthly users, 96.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $100.00 / 1,000 ai responses

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Satoshi-Nakamoto

> Don't trust. Verify.

An experimental AI blockchain engineer inspired by the technical principles associated with Bitcoin, cryptography, distributed systems, and cypherpunk engineering.

This is an artificial intelligence persona, not the real Satoshi Nakamoto.

The purpose is simple:

**Take the problem apart.\
Make the assumptions explicit.\
Verify the result.**

### What it does

Give the Actor a technical problem and it will analyze it as a protocol engineer.

It is designed for questions involving:

- Bitcoin
- Blockchain architecture
- Cryptography
- Proof of Work
- Consensus mechanisms
- Distributed systems
- UTXO models
- Peer-to-peer networking
- Protocol security
- C++
- Rust
- Python

The emphasis is on reasoning about systems rather than producing confident-looking answers.

### Engineering principles

**Minimize trust.**

A system should not depend on an assumption that can be removed.

**Make assumptions explicit.**

If an argument depends on an assumption, state it.

**Prefer simple mechanisms.**

Complexity creates additional states, dependencies, and failure modes.

**Verify the result.**

A plausible answer is not proof.

### How it works

The Actor receives a task and sends it to a DeepSeek model through a private API connection.

The API credential is stored as a secret on Apify and is never provided to Actor users.

Each successfully generated response is billed as one Pay Per Event (`ai-response`).

The user supplies the task.

The infrastructure handles the model connection.

### Example

Ask:

> Design a Bitcoin-style proof-of-work blockchain and identify the assumptions required for its security.

The response should cover the protocol, assumptions, attack surface, trade-offs, and implementation considerations.

For protocol questions, the important part is not only **what works**.

It is also:

**Why does it work?**

And:

**Under which assumptions does it stop working?**

### Identity

The name refers to the pseudonymous creator associated with Bitcoin.

The intelligence behind this Actor is artificial.

It is not presented as the real Satoshi Nakamoto.

It is an experimental reconstruction of a particular engineering mindset:

> verify, minimize trust, and make the protocol speak for itself.

***

**The protocol is the proof.**

# Actor input Schema

## `task` (type: `string`):

Describe the blockchain, Bitcoin, cryptography, distributed-systems, or software-engineering problem you want the AI to analyze.

## `model` (type: `string`):

DeepSeek model used to generate the response.

## Actor input object example

```json
{
  "task": "Design a secure Bitcoin-style proof-of-work blockchain architecture and explain the main security assumptions.",
  "model": "deepseek-flash"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "task": "Design a secure Bitcoin-style proof-of-work blockchain architecture and explain the main security assumptions."
};

// Run the Actor and wait for it to finish
const run = await client.actor("satoshi-nakamoto/satoshi-nakamoto").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "task": "Design a secure Bitcoin-style proof-of-work blockchain architecture and explain the main security assumptions." }

# Run the Actor and wait for it to finish
run = client.actor("satoshi-nakamoto/satoshi-nakamoto").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "task": "Design a secure Bitcoin-style proof-of-work blockchain architecture and explain the main security assumptions."
}' |
apify call satoshi-nakamoto/satoshi-nakamoto --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,satoshi-nakamoto/satoshi-nakamoto"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/oJsL1MI1JNWDciFc1/builds/OlBgoi5KAAwjbNoMH/openapi.json