OnChain Crypto Currency API v1.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Swagger definition for this API is available at https://onchain.io/docs/onchain.swagger.json

Base URLs:

• https://onchain.io

Email: onchain.io Web: onchain.io

Authentication

• API Key (ApiKeyAuth)
  • Parameter Name: X-API-KEY, in: header.

Address

GetBalance

Code samples

# You can also use wget
curl -X GET https://onchain.io/api/address/balance/{coin_type}/{address} \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

GET https://onchain.io/api/address/balance/{coin_type}/{address} HTTP/1.1
Host: onchain.io
Accept: application/json

var headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/address/balance/{coin_type}/{address}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/address/balance/{coin_type}/{address}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.get 'https://onchain.io/api/address/balance/{coin_type}/{address}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.get('https://onchain.io/api/address/balance/{coin_type}/{address}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/address/balance/{coin_type}/{address}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://onchain.io/api/address/balance/{coin_type}/{address}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://onchain.io/api/address/balance/{coin_type}/{address}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

GET /api/address/balance/{coin_type}/{address}

Get Balance

Returns the satoshi balance, usd balance and user viewable balance for an address. For ERC20 tokens you need to pass in the contract ID and the number of decimal places.

Parameters

Enumerated Values

Example responses

200 Response

{
  "usd_balance": 0,
  "balance": 0,
  "unconfirmed_balance": 0,
  "human_balance": 0,
  "human_unconfirmed_balance": 0
}

Responses

GetBalances

Code samples

# You can also use wget
curl -X GET https://onchain.io/api/address/balances/{coin_type}/{addresses} \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

GET https://onchain.io/api/address/balances/{coin_type}/{addresses} HTTP/1.1
Host: onchain.io
Accept: application/json

var headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/address/balances/{coin_type}/{addresses}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/address/balances/{coin_type}/{addresses}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.get 'https://onchain.io/api/address/balances/{coin_type}/{addresses}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.get('https://onchain.io/api/address/balances/{coin_type}/{addresses}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/address/balances/{coin_type}/{addresses}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://onchain.io/api/address/balances/{coin_type}/{addresses}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://onchain.io/api/address/balances/{coin_type}/{addresses}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

GET /api/address/balances/{coin_type}/{addresses}

Get Balances

Returns the satoshi balance, usd balance and user viewable balance for a set of addresses.

Parameters

Enumerated Values

Example responses

200 Response

{
  "addresses": [
    {
      "address": "string",
      "usd_balance": 0,
      "balance": 0,
      "unconfirmed_balance": 0,
      "human_balance": 0,
      "human_unconfirmed_balance": 0
    }
  ],
  "totals": {
    "usd_balance": 0,
    "balance": 0,
    "unconfirmed_balance": 0,
    "human_balance": 0,
    "human_unconfirmed_balance": 0
  }
}

Responses

GetHistory

Code samples

# You can also use wget
curl -X GET https://onchain.io/api/address/history/{coin_type}/{addresses} \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

GET https://onchain.io/api/address/history/{coin_type}/{addresses} HTTP/1.1
Host: onchain.io
Accept: application/json

var headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/address/history/{coin_type}/{addresses}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/address/history/{coin_type}/{addresses}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.get 'https://onchain.io/api/address/history/{coin_type}/{addresses}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.get('https://onchain.io/api/address/history/{coin_type}/{addresses}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/address/history/{coin_type}/{addresses}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://onchain.io/api/address/history/{coin_type}/{addresses}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://onchain.io/api/address/history/{coin_type}/{addresses}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

GET /api/address/history/{coin_type}/{addresses}

Get History

Returns the transaction history for an address or addresses.

Parameters

Enumerated Values

Example responses

200 Response

{
  "total_txs": 0,
  "txs": [
    {
      "confirmations": 0,
      "time": 0,
      "is_deposit": true,
      "address": "string",
      "amount": 0,
      "human_amount": 0
    }
  ]
}

Responses

GetNetworkAddress

Code samples

# You can also use wget
curl -X GET https://onchain.io/api/address/{coin_type}/{public_key} \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

GET https://onchain.io/api/address/{coin_type}/{public_key} HTTP/1.1
Host: onchain.io
Accept: application/json

var headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/address/{coin_type}/{public_key}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');

const headers = {
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/address/{coin_type}/{public_key}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.get 'https://onchain.io/api/address/{coin_type}/{public_key}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.get('https://onchain.io/api/address/{coin_type}/{public_key}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/address/{coin_type}/{public_key}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "https://onchain.io/api/address/{coin_type}/{public_key}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('GET','https://onchain.io/api/address/{coin_type}/{public_key}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

GET /api/address/{coin_type}/{public_key}

Parameters

Enumerated Values

Example responses

200 Response

{
  "network_address": "string"
}

Responses

ERC20Transaction

CreateTransaction

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/erc20/create \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/erc20/create HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/erc20/create',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "to": "string",
  "amount": "string",
  "gas_price": 0,
  "gas_limit": 0,
  "contract_id": "string",
  "decimal_places": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/erc20/create',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/erc20/create',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/erc20/create', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/erc20/create");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/erc20/create", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/erc20/create', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/erc20/create

Body parameter

{
  "to": "string",
  "amount": "string",
  "gas_price": 0,
  "gas_limit": 0,
  "contract_id": "string",
  "decimal_places": 0
}

Parameters

Example responses

200 Response

{
  "tx": "string",
  "to_sign": "string"
}

Responses

SignAndSend

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/erc20/sign_and_send \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/erc20/sign_and_send HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/erc20/sign_and_send',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "tx": "string",
  "v": 0,
  "r": "string",
  "s": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/erc20/sign_and_send',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/erc20/sign_and_send',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/erc20/sign_and_send', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/erc20/sign_and_send");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/erc20/sign_and_send", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/erc20/sign_and_send', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/erc20/sign_and_send

Body parameter

{
  "tx": "string",
  "v": 0,
  "r": "string",
  "s": "string"
}

Parameters

Example responses

200 Response

{
  "tx_hash": "string"
}

Responses

EthereumTransaction

CreateTransaction

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/ethereum/create \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/ethereum/create HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/ethereum/create',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "to": "string",
  "from": "string",
  "amount": "string",
  "gas_price": 0,
  "gas_limit": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/ethereum/create',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/ethereum/create',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/ethereum/create', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/ethereum/create");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/ethereum/create", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/ethereum/create', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/ethereum/create

Body parameter

{
  "to": "string",
  "from": "string",
  "amount": "string",
  "gas_price": 0,
  "gas_limit": 0
}

Parameters

Example responses

200 Response

{
  "tx": "string",
  "to_sign": "string"
}

Responses

SignAndSend

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/ethereum/sign_and_send \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/ethereum/sign_and_send HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/ethereum/sign_and_send',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "tx": "string",
  "v": 0,
  "r": "string",
  "s": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/ethereum/sign_and_send',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/ethereum/sign_and_send',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/ethereum/sign_and_send', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/ethereum/sign_and_send");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/ethereum/sign_and_send", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/ethereum/sign_and_send', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/ethereum/sign_and_send

Body parameter

{
  "tx": "string",
  "v": 0,
  "r": "string",
  "s": "string"
}

Parameters

Example responses

200 Response

{
  "tx_hash": "string"
}

Responses

MultiSigTransaction

CreateTransaction

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/multi_sig/create/{coin_type} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/multi_sig/create/{coin_type} HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/multi_sig/create/{coin_type}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "coin_type": "BITCOIN",
  "recipients": [
    {
      "to": "string",
      "amount": 0
    }
  ],
  "public_keys": [
    "string"
  ],
  "miners_fee": 0,
  "number_of_required_signatures": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/multi_sig/create/{coin_type}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/multi_sig/create/{coin_type}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/multi_sig/create/{coin_type}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/multi_sig/create/{coin_type}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/multi_sig/create/{coin_type}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/multi_sig/create/{coin_type}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/multi_sig/create/{coin_type}

Body parameter

{
  "coin_type": "BITCOIN",
  "recipients": [
    {
      "to": "string",
      "amount": 0
    }
  ],
  "public_keys": [
    "string"
  ],
  "miners_fee": 0,
  "number_of_required_signatures": 0
}

Parameters

Enumerated Values

Example responses

200 Response

{
  "tx": "string",
  "total_input_value": 0,
  "hashes_to_sign": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}

Responses

SignAndSend

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/multi_sig/sign_and_send/{coin_type} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/multi_sig/sign_and_send/{coin_type} HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/multi_sig/sign_and_send/{coin_type}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "coin_type": "BITCOIN",
  "tx": "string",
  "signatures": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/multi_sig/sign_and_send/{coin_type}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/multi_sig/sign_and_send/{coin_type}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/multi_sig/sign_and_send/{coin_type}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/multi_sig/sign_and_send/{coin_type}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/multi_sig/sign_and_send/{coin_type}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/multi_sig/sign_and_send/{coin_type}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/multi_sig/sign_and_send/{coin_type}

Body parameter

{
  "coin_type": "BITCOIN",
  "tx": "string",
  "signatures": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}

Parameters

Enumerated Values

Example responses

200 Response

{
  "tx_hash": "string"
}

Responses

Transaction

CreateTransaction

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/transaction/create/{coin_type} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/transaction/create/{coin_type} HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/transaction/create/{coin_type}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "coin_type": "BITCOIN",
  "recipients": [
    {
      "to": "string",
      "amount": 0
    }
  ],
  "from": "string",
  "from_address": "string",
  "miners_fee": 0
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/transaction/create/{coin_type}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/transaction/create/{coin_type}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/transaction/create/{coin_type}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/transaction/create/{coin_type}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/transaction/create/{coin_type}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/transaction/create/{coin_type}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/transaction/create/{coin_type}

Body parameter

{
  "coin_type": "BITCOIN",
  "recipients": [
    {
      "to": "string",
      "amount": 0
    }
  ],
  "from": "string",
  "from_address": "string",
  "miners_fee": 0
}

Parameters

Enumerated Values

Example responses

200 Response

{
  "tx": "string",
  "total_input_value": 0,
  "hashes_to_sign": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}

Responses

SendRaw

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/transaction/send_raw/{coin_type} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/transaction/send_raw/{coin_type} HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/transaction/send_raw/{coin_type}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "coin_type": "BITCOIN",
  "tx": "string"
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/transaction/send_raw/{coin_type}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/transaction/send_raw/{coin_type}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/transaction/send_raw/{coin_type}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/transaction/send_raw/{coin_type}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/transaction/send_raw/{coin_type}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/transaction/send_raw/{coin_type}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/transaction/send_raw/{coin_type}

Body parameter

{
  "coin_type": "BITCOIN",
  "tx": "string"
}

Parameters

Enumerated Values

Example responses

200 Response

{
  "tx_hash": "string"
}

Responses

SignAndSend

Code samples

# You can also use wget
curl -X POST https://onchain.io/api/transaction/sign_and_send/{coin_type} \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json' \
  -H 'X-API-KEY: API_KEY'

POST https://onchain.io/api/transaction/sign_and_send/{coin_type} HTTP/1.1
Host: onchain.io
Content-Type: application/json
Accept: application/json

var headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

$.ajax({
  url: 'https://onchain.io/api/transaction/sign_and_send/{coin_type}',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const fetch = require('node-fetch');
const inputBody = '{
  "coin_type": "BITCOIN",
  "tx": "string",
  "signatures": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json',
  'Accept':'application/json',
  'X-API-KEY':'API_KEY'

};

fetch('https://onchain.io/api/transaction/sign_and_send/{coin_type}',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json',
  'Accept' => 'application/json',
  'X-API-KEY' => 'API_KEY'
}

result = RestClient.post 'https://onchain.io/api/transaction/sign_and_send/{coin_type}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json',
  'Accept': 'application/json',
  'X-API-KEY': 'API_KEY'
}

r = requests.post('https://onchain.io/api/transaction/sign_and_send/{coin_type}', params={

}, headers = headers)

print r.json()

URL obj = new URL("https://onchain.io/api/transaction/sign_and_send/{coin_type}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json"},
        "Accept": []string{"application/json"},
        "X-API-KEY": []string{"API_KEY"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "https://onchain.io/api/transaction/sign_and_send/{coin_type}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

 'application/json',
    'Accept' => 'application/json',
    'X-API-KEY' => 'API_KEY',
    
    );

$client = new \GuzzleHttp\Client();

// Define array of request body.
$request_body = array();

try {
    $response = $client->request('POST','https://onchain.io/api/transaction/sign_and_send/{coin_type}', array(
        'headers' => $headers,
        'json' => $request_body,
       )
    );
    print_r($response->getBody()->getContents());
 }
 catch (\GuzzleHttp\Exception\BadResponseException $e) {
    // handle exception or api errors.
    print_r($e->getMessage());
 }

 // ...

POST /api/transaction/sign_and_send/{coin_type}

Body parameter

{
  "coin_type": "BITCOIN",
  "tx": "string",
  "signatures": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}

Parameters

Enumerated Values

Example responses

200 Response

{
  "tx_hash": "string"
}

Responses

Schemas

google.protobuf.Any

{
  "type_url": "string",
  "value": "string"
}

*Any contains an arbitrary serialized protocol buffer message along with a URL that describes the type of the serialized message.

Protobuf library provides support to pack/unpack Any values in the form of utility functions or additional generated methods of the Any type.

Example 1: Pack and unpack a message in C++.

Foo foo = ...;
Any any;
any.PackFrom(foo);
...
if (any.UnpackTo(&foo)) {
  ...
}

Example 2: Pack and unpack a message in Java.

Foo foo = ...;
Any any = Any.pack(foo);
...
if (any.is(Foo.class)) {
  foo = any.unpack(Foo.class);
}

Example 3: Pack and unpack a message in Python.

foo = Foo(...)
any = Any()
any.Pack(foo)
...
if any.Is(Foo.DESCRIPTOR):
  any.Unpack(foo)
  ...

Example 4: Pack and unpack a message in Go

 foo := &pb.Foo{...}
 any, err := ptypes.MarshalAny(foo)
 ...
 foo := &pb.Foo{}
 if err := ptypes.UnmarshalAny(any, foo); err != nil {
   ...
 }

The pack methods provided by protobuf library will by default use 'type.googleapis.com/full.type.name' as the type URL and the unpack methods only use the fully qualified type name after the last '/' in the type URL, for example "foo.bar.com/x/y.z" will yield type name "y.z".

JSON

The JSON representation of an Any value uses the regular representation of the deserialized, embedded message, with an additional field @type which contains the type URL. Example:

package google.profile;
message Person {
  string first_name = 1;
  string last_name = 2;
}

{
  "@type": "type.googleapis.com/google.profile.Person",
  "firstName": ,
  "lastName": 
}

If the embedded message type is well-known and has a custom JSON representation, that representation will be embedded adding a field value which holds the custom JSON in addition to the @type field. Example (for message [google.protobuf.Duration][]):

{
  "@type": "type.googleapis.com/google.protobuf.Duration",
  "value": "1.212s"
}*

Properties

grpc.gateway.runtime.Error

{
  "error": "string",
  "code": 0,
  "message": "string",
  "details": [
    {
      "type_url": "string",
      "value": "string"
    }
  ]
}

Properties

onchain.AddressReply

{
  "network_address": "string"
}

Properties

onchain.BalanceAddressReply

{
  "address": "string",
  "usd_balance": 0,
  "balance": 0,
  "unconfirmed_balance": 0,
  "human_balance": 0,
  "human_unconfirmed_balance": 0
}

Properties

onchain.BalanceReply

{
  "usd_balance": 0,
  "balance": 0,
  "unconfirmed_balance": 0,
  "human_balance": 0,
  "human_unconfirmed_balance": 0
}

Properties

onchain.BalancesReply

{
  "addresses": [
    {
      "address": "string",
      "usd_balance": 0,
      "balance": 0,
      "unconfirmed_balance": 0,
      "human_balance": 0,
      "human_unconfirmed_balance": 0
    }
  ],
  "totals": {
    "usd_balance": 0,
    "balance": 0,
    "unconfirmed_balance": 0,
    "human_balance": 0,
    "human_unconfirmed_balance": 0
  }
}

Properties

onchain.CoinType

"BITCOIN"

Properties

Enumerated Values

onchain.ERC20TransactionRequest

{
  "to": "string",
  "amount": "string",
  "gas_price": 0,
  "gas_limit": 0,
  "contract_id": "string",
  "decimal_places": 0
}

Properties

onchain.EthereumTransactionReply

{
  "tx": "string",
  "to_sign": "string"
}

Properties

onchain.EthereumTransactionRequest

{
  "to": "string",
  "from": "string",
  "amount": "string",
  "gas_price": 0,
  "gas_limit": 0
}

Properties

onchain.EthereumTransactionSendRequest

{
  "tx": "string",
  "v": 0,
  "r": "string",
  "s": "string"
}

Properties

onchain.HashToSign

{
  "input_index": 0,
  "public_key": "string",
  "hash_to_sign": "string",
  "signature": "string"
}

Properties

onchain.HistoryReply

{
  "total_txs": 0,
  "txs": [
    {
      "confirmations": 0,
      "time": 0,
      "is_deposit": true,
      "address": "string",
      "amount": 0,
      "human_amount": 0
    }
  ]
}

Properties

onchain.HistoryReply.TX

{
  "confirmations": 0,
  "time": 0,
  "is_deposit": true,
  "address": "string",
  "amount": 0,
  "human_amount": 0
}

Properties

onchain.MultiSigTransactionRequest

{
  "coin_type": "BITCOIN",
  "recipients": [
    {
      "to": "string",
      "amount": 0
    }
  ],
  "public_keys": [
    "string"
  ],
  "miners_fee": 0,
  "number_of_required_signatures": 0
}

Properties

onchain.RawTransactionSendRequest

{
  "coin_type": "BITCOIN",
  "tx": "string"
}

Properties

onchain.TransactionRecipient

{
  "to": "string",
  "amount": 0
}

Properties

onchain.TransactionReply

{
  "tx": "string",
  "total_input_value": 0,
  "hashes_to_sign": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}

Properties

onchain.TransactionRequest

{
  "coin_type": "BITCOIN",
  "recipients": [
    {
      "to": "string",
      "amount": 0
    }
  ],
  "from": "string",
  "from_address": "string",
  "miners_fee": 0
}

Properties

onchain.TransactionSendReply

{
  "tx_hash": "string"
}

Properties

onchain.TransactionSendRequest

{
  "coin_type": "BITCOIN",
  "tx": "string",
  "signatures": [
    {
      "input_index": 0,
      "public_key": "string",
      "hash_to_sign": "string",
      "signature": "string"
    }
  ]
}

Properties