rustbin.site Open in urlscan Pro
2606:4700:3030::ac43:c081  Public Scan

Form analysis
0 forms found in the DOM

Text Content

Rust Bin

 * ~> Home
 * ~> About
 * ~> Code
 * ~> Contact


DON'T USE FOR: ILLE|

~> Donate

~> Example




ABOUT

We have some rate limits (25 requestss per 1 minute) to save our servers from
overload.

If you want to have unlimited speed - contact us

TOTAL

237638

VISA

99736

MASTERCARD

48947

DINERS CLUB INTERNATIONAL

28501

AMERICAN EXPRESS

19801

MAESTRO

13756

EBT

12242

JCB

6987

CIRRUS

3882

ELO

1089

PRIVATE LABEL

975

RUPAY

504

JCB/RUPAY

488

VERVE

201

CARNET

173

VISA/DANKORT

100

DANKORT

100

LOCAL BRAND

72

BANKCARD(INACTIVE)

21

MAESTRO/BANCONTACT

19

EFTPOS

13

TARJETA NARANJA

7

MEEZA

4

HIPERCARD

3

VISA/BANCONTACT

2

MASTERCARD/BANCONTACT

2

CODENSA

2

CMI

2

ARGENCARD

2

JCB/MIR

1

JCB/LANKAPAY

1

JCB/CHINA UNION PAY

1

FUEL CARD

1

CABAL

1

AURA

1

ATM CARD

1


CODE EXAMPLES


RUST

use reqwest::blocking::Client;
use serde::Deserialize;
use std::error::Error;
use std::fmt;

#[derive(Debug, Deserialize)]
struct BinInfo {
    bin: String,
    brand: String,
    #[serde(rename = "type")]
    bin_type: String,
    level: String,
    bank: String,
    url: String,
    phone: String,
    country: String,
}

#[derive(Debug)]
struct BinError(String);

impl fmt::Display for BinError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.0)
    }
}

impl Error for BinError {}

fn main() -> Result<(), Box> {
    let bin = 123456;
    let url = format!("https://rustbin.site/api?bin={}", bin);
    let client = Client::new();
    let resp = client.get(&url).send()?;
    match resp.status() {
        StatusCode::NOT_FOUND => {
            println!("BIN not found. Received 404 response.");
            Ok(())
        }
        StatusCode::OK => {
            let bin_info: BinInfo = resp.json()?;
            println!("BIN Information:\n{:?}", bin_info);
            Ok(())
        }
        status => {
            Err(Box::new(BinError(format!(
                "Error: received non-200 status code: {}",
                status
            ))))
        }
    }
}



GO

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "log"
    "net/http"
)

type BinInfo struct {
    Bin    string `json:"bin"`
    Brand  string `json:"brand"`
    Type   string `json:"type"`
    Level  string `json:"level"`
    Bank   string `json:"bank"`
    URL    string `json:"url"`
    Phone  string `json:"phone"`
    Country string `json:"country"`
}

func main() {
    bin := 123456
    url := fmt.Sprintf("https://rustbin.site/api?bin=%d", bin)
    resp, err := http.Get(url)
    if err != nil {
        log.Fatalf("Error making request: %v", err)
    }
    defer resp.Body.Close()
    if resp.StatusCode == http.StatusNotFound {
        fmt.Println("BIN not found. Received 404 response.")
        return
    }
    if resp.StatusCode != http.StatusOK {
        log.Fatalf("Error: received non-200 status code: %d", resp.StatusCode)
    }
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        log.Fatalf("Error reading response body: %v", err)
    }
    var binInfo BinInfo
    err = json.Unmarshal(body, &binInfo)
    if err != nil {
        log.Fatalf("Error parsing JSON: %v", err)
    }
}


JAVASCRIPT

async function main() {
    const bin = 123456;
    const url = `https://rustbin.site/api?bin=${bin}`;
    try {
        const response = await fetch(url);
        if (response.status === 404) {
            console.log("BIN not found. Received 404 response.");
            return;
        }
        if (!response.ok) {
            throw new Error(`Error: received non-200 status code: ${response.status}`);
        }
        const data = await response.json();
    } catch (error) {
        console.error(`Error: ${error.message}`);
    }
}

main();



PHP

<?php
$bin = 123456;
$url = "https://rustbin.site/api?bin=" . $bin;
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
if (curl_errno($ch)) {
    echo 'Request error: ' . curl_error($ch);
    exit;
}
$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
curl_close($ch);
if ($httpCode == 404) {
    echo "BIN not found. Received 404 response.";
    exit;
}
$data = json_decode($response, true);



PYTHON

import requests
import json

def main():
    bin = 123456
    url = f"https://rustbin.site/api?bin={bin}"

    try:
        response = requests.get(url)
        response.raise_for_status()
    except requests.exceptions.HTTPError as err:
        if response.status_code == 404:
            print("BIN not found. Received 404 response.")
            return
        else:
            raise SystemExit(f"Error: received non-200 status code: {response.status_code}") from err
    except Exception as e:
        raise SystemExit(f"Error making request: {e}")

    try:
        data = response.json()
    except json.JSONDecodeError as e:
        raise SystemExit(f"Error parsing JSON: {e}")

if __name__ == "__main__":
    main()



CONTACT

JABBER

solidarnost@exploit.im

TOX

B69037A690A9CDCAD05D2CB1333597C9B21FF84E9A4CAB5F8BCCC4425B52E80CF114E9041BC7

MONERO

84xhybmWANjBRwZF8Wt4cYhJEcAR2QgCoGuAPGaXkZLuRA3Jx5HqAcYhsVk1Ku6GmWA22mAGbdbkWWGubQoyH7MRUkSM28m

BITCOIN

3FQYCHNhxSxdQTFdznzpR2z3WKvHKyPJM9