Obtenir les données historiques de Bitcoin [fermé]

Je veux créer mon propre graphique Bitcoin.

Connaissez-vous un moyen fiable de récupérer les données de prix historiques des bitcoins? Existe-t-il un moyen de le récupérer en utilisant REST? J'ai vu Bitfloor, qui prend en charge REST, mais il ne renvoie aucune valeur utile, il a une "erreur de serveur interne".

J'ai aussi vu des Bitcoincharts, mais je pense que c'est limité à 2000 valeurs de données.

Pouvez-vous me suggérer un cadre ou un système pour y travailler?

En fait, vous POUVEZ obtenir l'historique complet des transactions Bitcoin à partir de Bitcoincharts au format CSV ici: http://api.bitcoincharts.com/v1/csv/

il est mis à jour deux fois par jour pour les échanges actifs, et il y a aussi quelques échanges morts.

EDIT: Puisqu'il n'y a pas d'en-têtes de colonne dans les CSV, voici ce qu'ils sont: colonne 1) l'horodatage de la transaction, colonne 2) le prix, colonne 3) le volume de la transaction

Vous pouvez trouver de nombreuses données historiques ici: https://www.quandl.com/data/BCHARTS-Bitcoin-Charts-Exchange-Rate-Data

Si vous souhaitez collecter des données de trading bitstamp depuis leur websocket avec une résolution plus élevée sur une période plus longue, vous pouvez utiliser le script log_bitstamp_trades.py ci-dessous.

Le script utilise les bibliothèques python websocket-client et pusher_client_python, donc installez-les.

#!/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

et configuration du fichier logrotate

/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
}

alors vous pouvez l'exécuter en arrière-plan

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

Bitstamp a des données en direct de Bitcoin qui sont accessibles au public dans JSONà ce lien . N'essayez pas d'y accéder plus de 600 fois en dix minutes, sinon ils bloqueront votre adresse IP (en plus, c'est inutile de toute façon; en savoir plus ici ). Voici une C#approche pour obtenir des données en direct:

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
}

À partir de là, vous pouvez analyser le JSONet le stocker dans une base de données (ou l' MongoDBinsérer directement), puis y accéder.

Pour les données historiques (en fonction de la base de données - si c'est ainsi que vous l'abordez), faites une insertion à partir d'un fichier plat, que la plupart des bases de données vous permettent d'utiliser (par exemple, avec SQL Servervous pouvez faire un à BULK INSERTpartir d'un CSVfichier).

J'ai écrit un exemple java pour ce cas:

Utilisez la bibliothèque json.org pour récupérer les JSONObjects et JSONArrays. L'exemple ci-dessous utilise les données de blockchain.info qui peuvent être obtenues sous forme de 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 dispose d'une API REST qui vous donne accès aux prix historiques de leur site Web. Les données semblent montrer le prix au comptant de Coinbase (en USD) toutes les dix minutes environ.

Les résultats sont renvoyés au format CSV. Vous devez interroger le numéro de page souhaité via l'API. Il y a 1000 résultats (ou points de prix) par page. Cela représente environ 7 jours de données par page.

Le scraping en JSON avec Node.js serait amusant :)

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)
  ]
]