Obtener datos históricos de bitcoin [cerrado]

Quiero hacer mi propio gráfico de bitcoin.

¿Conocería alguna forma confiable de recuperar datos históricos de precios de bitcoins? ¿Hay alguna forma de recuperarlo usando REST? Vi Bitfloor, que admite REST, pero no devuelve ningún valor útil, tiene un "error interno del servidor".

También vi Bitcoincharts, pero creo que está limitado a 2000 valores de datos.

¿Me sugeriría algún marco o sistema para trabajar al respecto?

En realidad, PUEDES obtener todo el historial de operaciones de Bitcoin de Bitcoincharts en formato CSV aquí: http://api.bitcoincharts.com/v1/csv/

se actualiza dos veces al día para intercambios activos, y también hay algunos intercambios muertos.

EDITAR: Dado que no hay encabezados de columna en los CSV, esto es lo que son: columna 1) la marca de tiempo de la operación, columna 2) el precio, columna 3) el volumen de la operación

Puede encontrar muchos datos históricos aquí: https://www.quandl.com/data/BCHARTS-Bitcoin-Charts-Exchange-Rate-Data

En caso de que desee recopilar datos de comercio de sello de bits de su websocket en una resolución más alta durante un período de tiempo más largo, puede usar el script log_bitstamp_trades.py a continuación.

El script utiliza las bibliotecas python websocket-client y pusher_client_python, así que instálelas.

#!/usr/bin/python

import pusherclient
import time
import logging
import sys
import datetime
import signal
import os

logging.basicConfig()
log_file_fd = None

def sigint_and_sigterm_handler(signal, frame):
    global log_file_fd
    log_file_fd.close()
    sys.exit(0)


class BitstampLogger:

    def __init__(self, log_file_path, log_file_reload_path, pusher_key, channel, event):
        self.channel = channel
        self.event = event
        self.log_file_fd = open(log_file_path, "a")
        self.log_file_reload_path = log_file_reload_path
        self.pusher = pusherclient.Pusher(pusher_key)
        self.pusher.connection.logger.setLevel(logging.WARNING)
        self.pusher.connection.bind('pusher:connection_established', self.connect_handler)
        self.pusher.connect()

    def callback(self, data):
        utc_timestamp = time.mktime(datetime.datetime.utcnow().timetuple())
        line = str(utc_timestamp) + " " + data + "\n"
        if os.path.exists(self.log_file_reload_path):
            os.remove(self.log_file_reload_path)
            self.log_file_fd.close()
            self.log_file_fd = open(log_file_path, "a")
        self.log_file_fd.write(line)

    def connect_handler(self, data):
        channel = self.pusher.subscribe(self.channel)
        channel.bind(self.event, self.callback)


def main(log_file_path, log_file_reload_path):
    global log_file_fd
    bitstamp_logger = BitstampLogger(
        log_file_path,
        log_file_reload_path,
        "de504dc5763aeef9ff52",
        "live_trades",
        "trade")
    log_file_fd = bitstamp_logger.log_file_fd
    signal.signal(signal.SIGINT, sigint_and_sigterm_handler)
    signal.signal(signal.SIGTERM, sigint_and_sigterm_handler)
    while True:
        time.sleep(1)


if __name__ == '__main__':
    log_file_path = sys.argv[1]
    log_file_reload_path = sys.argv[2]
    main(log_file_path, log_file_reload_path

y logrotate la configuración del archivo

/mnt/data/bitstamp_logs/bitstamp-trade.log
{
    rotate 10000000000
    minsize 10M
    copytruncate
    missingok
    compress
    postrotate
        touch /mnt/data/bitstamp_logs/reload_log > /dev/null
    endscript
}

entonces puedes ejecutarlo en segundo plano

nohup ./log_bitstamp_trades.py /mnt/data/bitstamp_logs/bitstamp-trade.log /mnt/data/bitstamp_logs/reload_log &

Bitstamp tiene datos bitcoin en vivo que están disponibles públicamente en JSONen este enlace . No intente acceder a ella más de 600 veces en diez minutos o de lo contrario bloquearán su IP (además, de todos modos, es innecesario; lea más aquí ). El siguiente es un C#enfoque para obtener datos en vivo:

using (var WebClient = new System.Net.WebClient())
{
     var json = WebClient.DownloadString("https://www.bitstamp.net/api/ticker/");
     string value = Convert.ToString(json);
     // Parse/use from here
}

Desde aquí, puede analizar JSONy almacenarlo en una base de datos (o con MongoDBinsertarlo directamente) y luego acceder a él.

Para los datos históricos (dependiendo de la base de datos, si así es como lo aborda), inserte desde un archivo plano, que la mayoría de las bases de datos le permiten usar (por ejemplo, SQL Serverpuede hacerlo BULK INSERTdesde un CSVarchivo).

He escrito un ejemplo de Java para este caso:

Use la biblioteca json.org para recuperar JSONObjects y JSONArrays. El siguiente ejemplo utiliza los datos de blockchain.info que se pueden obtener como JSONObject.

    public class main 
    {
        public static void main(String[] args) throws MalformedURLException, IOException
        {
            JSONObject data = getJSONfromURL("https://blockchain.info/charts/market-price?format=json");
            JSONArray data_array = data.getJSONArray("values");

            for (int i = 0; i < data_array.length(); i++)
            {
                JSONObject price_point = data_array.getJSONObject(i);

                //  Unix time
                int x = price_point.getInt("x");

                //  Bitcoin price at that time
                double y = price_point.getDouble("y");

                //  Do something with x and y.
            }

        }

        public static JSONObject getJSONfromURL(String URL)
        {
            try
            {
                URLConnection uc;
                URL url = new URL(URL);
                uc = url.openConnection();
                uc.setConnectTimeout(10000);
                uc.addRequestProperty("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)");
                uc.connect();

                BufferedReader rd = new BufferedReader(
                        new InputStreamReader(uc.getInputStream(), 
                        Charset.forName("UTF-8")));

                StringBuilder sb = new StringBuilder();
                int cp;
                while ((cp = rd.read()) != -1)
                {
                    sb.append((char)cp);
                }

                String jsonText = (sb.toString());            

                return new JSONObject(jsonText.toString());
            } catch (IOException ex)
            {
                return null;
            }
        }
    }

Coinbase tiene una API REST que le brinda acceso a precios históricos desde su sitio web. Los datos parecen mostrar el precio spot de Coinbase (en USD) aproximadamente cada diez minutos.

Los resultados se devuelven en formato CSV. Debe consultar el número de página que desea a través de la API. Hay 1000 resultados (o puntos de precio) por página. Eso equivale a unos 7 días de datos por página.

Rasparlo a JSON con Node.js sería divertido :)

https://github.com/f1lt3r/bitcoin-scraper

[
  [
    1419033600,  // Timestamp (1 for each minute of entire history)
    318.58,      // Open
    318.58,      // High
    318.58,      // Low
    318.58,      // Close
    0.01719605,  // Volume (BTC)
    5.478317609, // Volume (Currency)
    318.58       // Weighted Price (USD)
  ]
]