DEV Community: CoinAPI

How to retrieve and analyze crypto order book data using Python and a cryptocurrency API

Ada from CoinAPI — Mon, 27 Nov 2023 13:09:17 +0000

In this guide, we'll explore how to access and examine order book data for cryptocurrencies by utilizing Python and CoinAPI.

Agenda🔥:

Fundamentals of crypto order books: grasping the essentials of cryptocurrency trading order books.
Data retrieval: employing Python and CoinAPI for acquiring real-time crypto order book information.
Data interpretation: gleaning insights from cryptocurrency API information.
Data visualization: utilizing Python's Matplotlib for visualizing order book information.
Metrics calculation: deriving important metrics from cryptocurrency API data.

CoinAPI: Your go-to source for comprehensive cryptocurrency data 🚀

Before we jump into the tutorial, it's important to highlight what CoinAPI brings to the table. CoinAPI is a robust resource for a vast array of financial data, offering both real-time and historical information from numerous exchanges.

If you need in-depth trading data, OHLCV (Open, High, Low, Close, Volume) stats, or specific event details, CoinAPI has you covered. It stands out by providing detailed crypto order book data, positioning itself as a top-tier crypto API choice.

Moreover, CoinAPI's compatibility with various data delivery methods, such as REST and WebSocket, adds to its flexibility. This makes it an ideal tool for developers who are working on trading algorithms or visualizations of crypto market data.

Let's Begin 🚀

Utilizing the powerful features of CoinAPI, an advanced cryptocurrency API, in combination with Python's strengths in data analysis and statistics, allows us to deeply explore the complexities of the cryptocurrency market.

This guide will take you through the process of retrieving and examining crypto order book data in real-time, making full use of the extensive data available through the cryptocurrency API.

Setting up the API request

To fetch real-time order book data, you'll first need an API key from the CoinAPI website. Once you have it, you can proceed to retrieve the data using Python.

Fetching the data

import requests
import json

API_KEY = "YOUR_API_KEY_HERE"
url = f"https://rest.coinapi.io/v1/orderbooks/current?symbol=KRAKEN_SPOT_BTC_USD&apikey={API_KEY}"

response = requests.get(url)

if response.status_code == 200:
    # The request was successful
    data = response.json()

    # Save the data to a file
    with open("order-books-kraken-spot-btc-usd.json", "w") as file:
        json.dump(data, file, indent=4)
    print("Data saved to order-books-kraken-spot-btc-usd.json")
else:
    # Handle error cases
    print(f"Error: Status code {response.status_code}")
    print(response.text)

Response

{
    "symbol_id": "KRAKEN_SPOT_BTC_USD",
    "time_exchange": "2023-11-24T08:26:46.6928657Z",
    "time_coinapi": "2023-11-24T08:26:46.6928657Z",
    "asks": [
        {
            "price": 37549.1,
            "size": 19.23618731
        },
        {
            "price": 37549.9,
            "size": 0.08242079
        },
        /// other entries omitted for brevity
    ],
    "bids": [
        {
            "price": 37549.0,
            "size": 0.136004
        },
        {
            "price": 37545.1,
        }
        /// other entries omitted for brevity
    ]
}

Data Analysis and Metrics

Once the data is retrieved, the subsequent phase is its analysis using Python.

The data you gather usually reflects a momentary picture of the market's buy and sell orders. It includes two principal elements: bids and asks. Bids indicate the prices buyers are prepared to pay for an asset, whereas asks show the prices sellers are ready to accept. The gap between the top bid and the bottom ask is known as the spread.

Here is a comprehensive list of common metrics and analytical procedures:

Order Book Depth - visualize the liquidity available at various price levels.
Order Imbalance - analyze the disparity between bids and asks to gain insights into market sentiment.
Price Levels - identify significant price levels characterized by substantial volumes of bids or asks.
Market Spread - compute the current bid-ask spread as an indicator of market liquidity.

Order book depth visualization

In this Python code, we demonstrate how to visualize the order book depth of a cryptocurrency trading pair using Matplotlib.

import json
import matplotlib.pyplot as plt

# Function to read order book data from a JSON
def read_order_book_data(file_path):
    with open(file_path, 'r') as file:
        order_book_data = json.load(file)
    return order_book_data

file_path = 'order-books-kraken-spot-btc-usd.json'

# Read order book data from the file we've obtained in the previous step
order_book_data = read_order_book_data(file_path)

# Function to visualize order book depth chart
def visualize_order_book_depth(order_book_data):
    bids = order_book_data["bids"]
    asks = order_book_data["asks"]

    bid_prices = [entry["price"] for entry in bids]
    bid_sizes = [entry["size"] for entry in bids]

    ask_prices = [entry["price"] for entry in asks]
    ask_sizes = [entry["size"] for entry in asks]

    plt.figure(figsize=(10, 6))
    plt.plot(bid_prices, bid_sizes, label="Bids (buyers)", color="green")
    plt.plot(ask_prices, ask_sizes, label="Asks (sellers)", color="red")
    plt.xlabel("Price")
    plt.ylabel("Size")
    plt.title("Order Book Depth")
    plt.legend()
    plt.show()

# Visualize the order book depth
visualize_order_book_depth(order_book_data)

The following visualization is the result of the Python script demonstrated above.

Order Book depth visualization:

is a measure of the quantity of buy and sell orders available for a particular financial asset
it provides insight into market liquidity and the willingness of traders to buy or sell at different prices
may be used for trading decisions, as it reveals potential price trends

Order imbalance, price levels, market spread

In this Python code, we explore order imbalance, significant bids & asks, and market spread metrics for a BTC/USD trading pair.

import json

# Function to read order book data from a JSON
def read_order_book_data(file_path):
    with open(file_path, 'r') as file:
        order_book_data = json.load(file)
    return order_book_data

file_path = 'order-books-kraken-spot-btc-usd.json'

# Read order book data from the file we've obtained in the previous step
order_book_data = read_order_book_data(file_path)

# Function to calculate order imbalance
def calculate_order_imbalance(order_book_data):
    bids = sum(entry["size"] for entry in order_book_data["bids"])
    asks = sum(entry["size"] for entry in order_book_data["asks"])

    order_imbalance = (bids - asks) / (bids + asks)
    return order_imbalance

# Function to identify significant price levels
def identify_significant_price_levels(order_book_data, threshold=50):
    bids = order_book_data["bids"]
    asks = order_book_data["asks"]

    significant_bids = [entry for entry in bids if entry["size"] > threshold]
    significant_asks = [entry for entry in asks if entry["size"] > threshold]
    return significant_bids, significant_asks

# Function to calculate market spread
def calculate_market_spread(order_book_data):
    best_bid = order_book_data["bids"][0]["price"]
    best_ask = order_book_data["asks"][0]["price"]

    spread = best_ask - best_bid
    return spread

# Common metrics calculation
order_imbalance = calculate_order_imbalance(order_book_data)
significant_price_threshold = 20
significant_bids, significant_asks = identify_significant_price_levels(order_book_data, significant_price_threshold)
spread = calculate_market_spread(order_book_data)

print("******************************")
print("Order Imbalance:", order_imbalance)
print("***************************")
print("Significant Bids:", significant_bids)
print("***************************")
print("Significant Asks:", significant_asks)
print("***************************")
print("Market Spread:", spread)
print("***************************")

Result

> ******************************
> Order Imbalance: -0.012400502029283922
> ***************************
> Significant Bids: [{'price': 37440.7, 'size': 24.73909889}, {'price': 36451.0, 'size': 25.0}]
> ***************************
> Significant Asks: [{'price': 37749.0, 'size': 25.0}, {'price': 37840.0, 'size': 24.08119208}, {'price': 38000.0, 'size': 29.60579175}, {'price': 39000.0, 'size': 21.75395535}, {'price': 40000.0, 'size': 58.28620718}]
> ***************************
> Market Spread: 0.09999999999854481
> ***************************

Calculated metrics:

order_imbalance - it measures the difference between the total volume of buy orders and sell orders. It provides insights into the overall market sentiment by indicating whether there is an excess of buying or selling interest.
significant_price_threshold is a predetermined value (set to 20 in this case) used to identify price levels in the order book that are considered significant. It helps traders focus on specific price points that may have a more substantial impact on the market.
significant_bids and significant_asks are lists of price levels derived from the order book data that meet or exceed the significant_price_threshold. These levels are typically associated with higher trading activity and may be seen as key support and resistance levels.
spread is a metric that calculates the difference between the best bid and best ask prices. It represents the cost of executing a market order and is a fundamental factor for traders to consider when entering or exiting positions.

Summary

This guide has provided you with essential skills and tools to retrieve and analyze cryptocurrency order book data using Python and CoinAPI. You've acquired the ability to access up-to-the-minute order book data, create visual representations of order book depth, and compute key trading metrics.

With this newfound knowledge, you're now better equipped to delve into the crypto markets, making more educated trading choices and crafting strategies based on solid data.

Keep in mind that the crypto market is ever-changing, so constant vigilance and analysis are key to staying on top of this vibrant and fast-paced sector.

Wishing you successful trading! 🚀📈💰

Thank you for reading!

The source code for this tutorial is available here

🔥Creating a historical crypto price chart using CoinAPI and D3.js 🪄

Ada from CoinAPI — Tue, 14 Nov 2023 15:38:04 +0000

TL;DR

In this tutorial, you'll learn how to utilize CoinAPI's RESTful API in a Node.js environment to fetch live cryptocurrency data. You'll also learn how to visualize this real-time data using D3.js within a React.js application, allowing for real-time, interactive data visualization.

Why do you need it?

CoinAPI's access to comprehensive, historical data, combined with D3.js's dynamic visualization capabilities, simplifies understanding complex market trends. This integration also eases data management and enhances customizability for specific analytical needs. Furthermore, the tutorial's step-by-step approach makes advanced data visualization more accessible to developers with varying skill levels. This not only aids in current data analysis but also equips users with essential tools for handling real-time data, crucial for informed decision-making in the rapidly changing cryptocurrency market.

🔥 On the agenda:

Retrieve up-to-the-minute cryptocurrency data using CoinAPI and Node.js.
Process and set up the data for effective visualization.
Develop a dynamic, historical price chart utilizing D3.js.
Enhance the chart's appearance with professional CSS styling.
Incorporate additional sophisticated features such as tooltips and zoom capabilities.

CoinAPI: Cryptocurrency data API 🚀

Just a quick background about us. CoinAPI is a crypto market data API that provides streamlined access to both real-time and historical financial data sourced from numerous exchanges globally. Catering to a wide range of needs, we offer everything from raw trading data, OHLCV (Open, High, Low, Close, Volume) data, to detailed information on specific market events. Our robust support for various data delivery methods, including REST and WebSocket, makes our API incredibly versatile and developer-friendly. It's an ideal tool for those aiming to create anything from trading algorithms to detailed financial visualizations.

Getting Started

First, create a new project folder on your computer and name it crypto_price_chart. Inside this folder, create three files: index.html, style.css, and script.js.

Setting up the API request

To fetch data from CoinAPI, we'll first need to make an API request. This will require an API key, which you can obtain by registering at the CoinAPI website.

Code Snippet: Prepare index.html

Here's the basic structure of a web page designed to visualize cryptocurrency closing prices over a specified period using D3.js.

<!doctype html>
<html>
  <head>
    <title>Coinapi</title>
    <script src="https://d3js.org/d3.v6.min.js"></script>
    <script src="script.js"></script>
    <link rel="stylesheet" href="style.css">
  </head>
    <h1>BTC Closing Prices Over Time</h1>
    <h3>(Data Period: 1 Day, Starting from January 1st, 2021, for 360 Days)</h3>
    <svg width="800" height="600"></svg>
</html>

Fetching Data from CoinAPI

Create a function in your script.js to fetch historical data.

const API_KEY = "YOUR_API_KEY_HERE";
const url = `https://rest.coinapi.io/v1/ohlcv/BITSTAMP_SPOT_BTC_USD/history?apikey=${API_KEY}&period_id=1DAY&time_start=2021-01-01T00:00:00&limit=360`;

async function fetchData() {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error('Network response was not ok');
    }
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching data:', error);
    throw error;
  }
}

Preparing the data

After fetching the data, it needs to be prepared for charting. We'll create a simple function to transform the data into a format that D3.js can easily interpret. Add it to the end of script.js.

Data transformation

function transformData(data) {
  return data.map(entry => ({
    date: new Date(entry.time_period_start),
    price: entry.price_close
  }));
}

Now let's dive into building the chart with D3.js🔥

Add this code at the end of your script.js file.

document.addEventListener('DOMContentLoaded', () => {
  const svg = d3.select("svg"); // Select the existing SVG element in the HTML

  fetchData()
    .then(data => {
      const transformedData = transformData(data);

      // Define chart dimensions
      const width = 800;
      const height = 600;
      const margin = { top: 50, right: 50, bottom: 50, left: 50 };

      // Create a group for the chart elements
      const chartGroup = svg.append("g")
        .attr("transform", `translate(${margin.left}, ${margin.top})`);

      // Create scales
      const xScale = d3.scaleUtc()
        .domain(d3.extent(transformedData, d => d.date))
        .range([0, width - margin.left - margin.right]);

      const yScale = d3.scaleLinear()
        .domain([0, d3.max(transformedData, d => d.price)])
        .range([height - margin.bottom - margin.top, 0]);

      // Create a line generator
      const line = d3.line()
        .x(d => xScale(d.date))
        .y(d => yScale(d.price));

      // Draw the line
      chartGroup.append("path")
        .datum(transformedData)
        .attr("class", "line")
        .attr("d", line);

      // Add axes
      chartGroup.append("g")
        .attr("class", "x-axis")
        .attr("transform", `translate(0, ${height - margin.bottom - margin.top})`)
        .call(d3.axisBottom(xScale));

      chartGroup.append("g")
        .attr("class", "y-axis")
        .call(d3.axisLeft(yScale));
    })
    .catch(error => console.log(error));
});

Styling the chart

Now, let's style your chart using the provided CSS. Add the following CSS to your style.css file:

body, h1, h2, h3, p, ul, li {
  margin: 5;
  padding: 0;
  color: white;
}

/* Set a gradient background for the body */
body {
  background: linear-gradient(to bottom, #080059, #6C4CFC);
}

/* Style the SVG container */
svg {
  background-color: transparent; /* Transparent background for the chart */
}

/* Style the chart line */
.line {
  fill: none;
  stroke: #6C4CFC; /* Purple color for the line */
  stroke-width: 2;
}

/* Style the x-axis */
.x-axis path,
.x-axis line {
  fill: none;
  stroke: #ccc; /* Light gray color for x-axis lines */
  shape-rendering: crispEdges;
}

.x-axis text {
  font-size: 12px;
  fill: white; /* Text color for the x-axis labels */
}

/* Style the y-axis */
.y-axis path,
.y-axis line {
  fill: none;
  stroke: #ccc; /* Light gray color for y-axis lines */
  shape-rendering: crispEdges;
}

.y-axis text {
  font-size: 12px;
  fill: white; /* Text color for the y-axis labels */
}

/* Style the legend */
.legend {
  font-size: 16px;
  text-align: right;
  color: white; /* Text color for the legend text */
}

Testing your chart

Save all your files and open index.html in a web browser. You should see a beautiful historical crypto price chart generated from real data!

Conclusion

Congratulations!🔥 You've successfully built a historical crypto price chart using CoinAPI and D3.js. This exercise demonstrated the power of APIs and data visualization libraries in creating interactive, informative visual tools.

Thank you for reading!

The source code for this tutorial is available here

How to use CoinAPI to access crypto exchange rates using Python, Javascript and Java.

Ada from CoinAPI — Thu, 07 Sep 2023 13:15:03 +0000

CoinAPI provides a powerful interface for interacting with multiple cryptocurrency markets, allowing for efficient data retrieval and processing.

This tutorial walks you through the process of using CoinAPI's API to access exchange rates data using Python, Javascript and Java.The objective here is to equip you with the necessary know-how to utilize our API for your crypto projects.

Prerequisites

A CoinAPI key (obtainable by signing up on the CoinAPI website)
Familiarity with RESTful APIs and JSON (JavaScript Object Notation)
A basic understanding of at least one programming language: Python, Javascript or Java

API Key Generation

Before we dive into code, it's crucial to understand that to use the CoinAPI, you need an API key. This key identifies your application and authorizes requests.

Visit the CoinAPI website.
Register an account or login if you already have one.
Navigate to the API Keys section and generate a new API key.

Remember to store your key safely - it's your credential!

Making an API Request with Python

To connect to CoinAPI in Python, we'll use the requests library. If you don't have the 'requests' library installed, you can add it using pip:

pip install requests

Here's an example of access-coinapi-data.py python script:

import requests

def fetch_data():
    url = "https://rest.coinapi.io/v1/exchangerate/BTC/USD"
    headers = {
        "X-CoinAPI-Key": "YOUR-API-KEY" # Replace with your API key
    }
    response = requests.get(url, headers=headers)
    return response.json()

print(fetch_data())

This script fetches the current exchange rate of Bitcoin (BTC) to USD.
To execute script, run python access-coinapi-data.py command.

python access-coinapi-data.py
{
    "time": "2023-07-24T11:31:56.0000000Z",
    "asset_id_base": "BTC",
    "asset_id_quote": "USD",
    "rate": 29295.929694597355
}

Note: Don't forget to replace YOUR-API-KEY with your actual API key.

Making an API Request with Javascript

Makes sure to install nodejs runtime environment before.
Add package.json with node-fetch module dependency.

{
  "type": "module",
  "dependencies": {
    "node-fetch": "^3.3.1"
  }
}

Create file access-coinapi-data.js with following code:

import fetch from 'node-fetch';

fetch('https://rest.coinapi.io/v1/exchangerate/BTC/USD', {
  headers: {
    "X-CoinAPI-Key": "YOUR_API_KEY" // Replace with your API key
    }
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));

This example fetches the current exchange rate from BTC to USD.

Install dependencies via npm install command.
Execute your program in nodejs runtime environment with node access-coinapi-data.js command.

>node access-coinapi-data.js
{
    "time": "2023-07-24T11:31:56.0000000Z",
    "asset_id_base": "BTC",
    "asset_id_quote": "USD",
    "rate": 29295.929694597355
}

Note: Don't forget to replace YOUR-API-KEY with your actual API key.

Making an API Request with Java

Make sure to install Java Development Kit (JDK) as it includes runtime environment (JRE) plus additional tools and utilities required for Java development. To check whether JRE and JDK are already installed on your system you may use java -version command.

Java offers multiple ways to send HTTP requests. Here we'll use the HttpURLConnection class.
Create Main.java file with following content:

import java.net.HttpURLConnection;
import java.net.URL;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

    private static final String API_KEY = "YOUR-API-KEY"; // Replace with your API key

    public static void main(String[] args) throws Exception {
        URL url = new URL("https://rest.coinapi.io/v1/exchangerate/BTC/USD");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
        conn.setRequestProperty("X-CoinAPI-Key", API_KEY);

        BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String inputLine;
        StringBuffer content = new StringBuffer();
        while ((inputLine = in.readLine()) != null) {
            content.append(inputLine);
        }

        in.close();
        conn.disconnect();

        System.out.println(content.toString());
    }
}

This script fetches the current exchange rate of Bitcoin (BTC) to USD.

Use javac Main.java command to compile java source file into bytecode.
Resulting bytecode file will be named Main.class.
After the compilation step, you can execute the program using java Main to see the exchange rate output.

>javac Main.Java
>java Main
{
    "time": "2023-07-24T11:31:56.0000000Z",
    "asset_id_base": "BTC",
    "asset_id_quote": "USD",
    "rate": 29295.929694597355
}

Note: Don't forget to replace YOUR-API-KEY with your actual API key.

Understanding the Response

CoinAPI returns data in JSON format, which we convert to a Python dictionary using response.json(). The /v1/exchangerate/BTC/USD endpoint response includes:

time: The timestamp of the last data update.

asset_id_base: The base asset (in our case, BTC).

asset_id_quote: The quote asset (in our case, USD).

rate: The current exchange rate from BTC to USD.

Converting Between Cryptocurrencies

The /v1/exchangerate/BTC/USD endpoint retrieves the current exchange rate of BTC to USD.

Additionally, the Exchange Rates endpoint provides the flexibility to obtain exchange rates between BTC and various other assets,
allowing users to access the conversion rates for multiple asset pairs involving BTC.

import requests 

url = 'https://rest.coinapi.io/v1/exchangerate/BTC' 
headers = {'X-CoinAPI-Key' : 'YOUR_API_KEY'} 
response = requests.get(url, headers=headers) 
print(response.json())

Here's the response for BTC exchange rate to various assets, e.g EUR, USD, ETH, XRP:

{
    "asset_id_base": "BTC",
    "rates": [
        {
            "time": "2023-07-24T13:00:43.0000000Z",
            "asset_id_quote": "EUR",
            "rate": 26371.195622912368
        },
        {
            "time": "2023-07-24T13:00:43.0000000Z",
            "asset_id_quote": "USD",
            "rate": 29222.332203558577
        },
        {
            "time": "2023-07-24T13:00:43.0000000Z",
            "asset_id_quote": "ETH",
            "rate": 15.780394091251145
        },
        {
            "time": "2023-07-24T13:00:43.0000000Z",
            "asset_id_quote": "XRP",
            "rate": 41915.164263881525
        },
        // ...more BTC exchange rates with various other assets...
}

To perform a cryptocurrency conversion from one currency to another, simply multiply the given amount by the exchange rate of the target cryptocurrency. Here's an example of converting 1.5 BTC to ETH:

import requests 
url = 'https://rest.coinapi.io/v1/exchangerate/BTC' 
headers = {'X-CoinAPI-Key' : "YOUR_API_KEY"}
response = requests.get(url, headers=headers) 

rates = response.json()['rates'] # exchange rates with BTC as base asset
eth_rate = [x['rate'] for x in rates if x['asset_id_quote'] == 'ETH'][0] # finding exchange rate for ETH (quote asset)
btc_amount = 1.5

eth_amount = btc_amount * eth_rate # actual conversion
print(f'1.5 BTC is equivalent to {eth_amount} ETH')

Below is the result of 1.5 BTC to ETH conversion:

console>python convert.py
1.5 BTC is equivalent to 23.671802476675076 ETH

Exchange rates endpoint plays a critical role in providing real-time conversion rates for cryptocurrencies.

The rate represents the conversion factor that determines the value of one unit of the base currency in terms of the target currency. It indicates how much of the target currency you would get in exchange for one unit of the base currency.

For more information, you can check REST API Exchange Rates docs

Best Practices

Security: never expose your API key publicly or commit it to version control. Store it in a secure and encrypted location and treat your API key as password.
Error Handling: CoinAPI can return various error codes (like 400, 403, 429) indicating issues such as invalid input or rate limit exceeding. Make sure to handle these potential errors in your code.
Rate Limiting: Ensure your application gracefully handles rate limit errors by implementing retry logic. Refer to CoinAPI's Rate Limiting documentation for more details.

Error Handling

Include robust error handling to account for potential issues such as network errors, API limits, or invalid responses.
Here's a simple example:

try:
    response = requests.get(url, headers=headers)
    response.raise_for_status()  # Raises a HTTPError if the status is 4xx, 5xx
except requests.exceptions.RequestException as err:
    print(f"An Error Occured: {err}")
else:
    data = response.json()

Rate Limiting

Keep track of your API usage to avoid hitting rate limits. CoinAPI provides different request tiers based on your subscription level.

print(response.headers.get("X-RateLimit-Used"))
print(response.headers.get("X-RateLimit-Limit"))
print(response.headers.get("X-RateLimit-Remaining"))
print(response.headers.get("X-RateLimit-Request-Cost"))
print(response.headers.get("X-RateLimit-Reset"))

For more information about rate limiting check REST API Limits.

API Key Security

Never expose your API key in a client-side application or a public code repository. Always keep it securely on your server.

Once your API key falls into the wrong hands, it can be used to make requests within your subscription.

Caching

To minimize API calls and maximize efficiency, consider implementing caching on your end.

Troubleshooting

If you encounter any issues while connecting to CoinAPI, make sure to:

Verify that your API key is correct.

Check if you have reached the API rate limit.
Confirm that you're using the right endpoint and method (GET, POST, etc.).
Ensure you've installed the correct libraries and dependencies and are using a supported version of the programming language.

You're now ready to use CoinAPI's API to access cryptocurrency data efficiently and effectively.
For more information, you can check REST API Exchange Rates docs

Happy coding!