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

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

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
$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);

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