# Blob

## Fetch blob from blockchain

The Blob object represents a blob, which is a file-like object of immutable, raw data; they can be read as text or binary data, or converted into a `ReadableStream` so its methods can be used for processing the data.

## Retrieve blob

<mark style="color:green;">`POST`</mark> `https://api.bloqifi.com/v0/blob`

Retrieve a blob

#### Headers

| Name         | Type   | Description      |
| ------------ | ------ | ---------------- |
| Content-Type | String | application/json |

#### Request Body

| Name                                         | Type   | Description                                |
| -------------------------------------------- | ------ | ------------------------------------------ |
| txids<mark style="color:red;">\*</mark>      | Array  | List of transaction id's \[`'123', '321']` |
| blockchain<mark style="color:red;">\*</mark> | String | `Bloqcoin`, `Dogecoin`, `Bitcoin`          |

{% tabs %}
{% tab title="200: OK " %}

```
Returns a hex string compressed with Brotli which contains
a concatenation of all of the data in the array passed into the constructor.
```

{% endtab %}

{% tab title="404: Not Found " %}

{% endtab %}
{% endtabs %}

Take a look at how you might call this method using our official libraries, or via `curl`:

{% tabs %}
{% tab title="JavaScript" %}

```javascript
const rawResponse = await fetch('https://api.bloqifi.com/v0/blob', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    blockchain: 'Bloqcoin',
    txids: ['123', '321']
  })
});

const result = await rawResponse.text();

if (rawResponse.status === 200) {

  const fromHexString = hexString => Uint8Array.from(hexString.match(/.{1,2}/g).map(byte => parseInt(byte, 16)));
  const compressedData = fromHexString(result);
  
  // data contains the raw brotli compressed data
  
  const decompressedData = brotli.decompress(compressedData);
  
  const textDecoder = new TextDecoder();
  
  console.log( textDecoder.decode(decompressedData) );
}
```

{% endtab %}

{% tab title="curl" %}

```
curl -X POST https://api.bloqifi.com/v0/blob \
-H "Content-Type: application/json" \
-d '{"blockchain": "Bloqcoin", "txids": ["123", "321"]}' 
```

{% endtab %}
{% endtabs %}

The output received from this endpoint is immutable, raw data compressed using `Brotli`

{% hint style="info" %}
**Good to know:** Notice that the Blockchain string used is capitalized, this is required.

In the example we will be using `Bloqcoin`, other supported blockchains are:

`Dogecoin`, `Bitcoin`
{% endhint %}

`Brotli` is a lossless data compression algorithm developed by Google. It uses a combination of the general-purpose LZ77 lossless compression algorithm, Huffman coding and 2nd order context modelling.

Install using NPM.

```
npm install brotli-wasm
```

A reliable compressor and de-compressor for Brotli, supporting node & browsers via wasm

**In node.js:**

```javascript
const * as brotli = require('brotli-wasm');

const compressedData = brotli.compress(Buffer.from('some input'));
const decompressedData = brotli.decompress(compressedData);

console.log(Buffer.from(decompressedData).toString('utf8')); // Prints 'some input'
```

**In browsers:**

```javascript
import brotliPromise from 'brotli-wasm'; // Import the default export

const brotli = await brotliPromise; // Import is async in browsers due to wasm requirements!

const compressedData = brotli.compress(Buffer.from('some input'));
const decompressedData = brotli.decompress(compressedData);

console.log(Buffer.from(decompressedData).toString('utf8')); // Prints 'some input'
```

## JavaScript Node

To construct a Blob from transaction ids, you can also use Bloqifi JavaScript Node:

`Bloqcoin` very fast. `Dogecoin` much reliable, Wow. // One line of code is all it takes.

```html
<script src="https://www.bloqifi.com/js/node.js" crossorigin="anonymous"></script>
```

{% hint style="info" %}
**Good to know:** The `integrity` and `crossorigin` attributes are used for [Subresource Integrity (SRI) checking](https://www.w3.org/TR/SRI/). This allows browsers to ensure that resources hosted on third-party servers have not been tampered with. Use of SRI is recommended as a best-practice, whenever libraries are loaded from a third-party source. Read more at [srihash.org](https://www.srihash.org/)
{% endhint %}

One line of code is all it takes to use images, text and more on your own website.

Include the Bloqifi JavaScript node on your site, and define your image tags:

```html
// Get data as Blob

<img class="Bloqcoin" type="blob" data-src="txids" data-mimetype="image/png" style="visibility:hidden;" />

// Retrieve data Chunked

<img class="Bloqcoin" type="chunk" data-src="txids" data-mimetype="image/png" style="visibility:hidden;" />

// Or utilize Dogecoin as blockchain

<img class="Dogecoin" type="blob" data-src="txids" data-mimetype="image/png" style="visibility:hidden;" />
<img class="Dogecoin" type="chunk" data-src="txids" data-mimetype="image/png" style="visibility:hidden;" />

// Even IPFS

<img class="IPFS" type="blob" data-src="hash" data-mimetype="image/png" style="visibility:hidden;" />
<img class="IPFS" type="chunk" data-src="hash" data-mimetype="image/png" style="visibility:hidden;" />
```

Join all your `bloq` transaction ids (txid) as one comma separated string, and add it as `data-src` on an image tag to show the image.

If you add images dynamically, you can hook up to the "ready" event

<pre class="language-javascript"><code class="lang-javascript">function listener(e) {
  window.hook('Bloqcoin');
  window.hook('Dogecoin');
  window.hook('Bitcoin');
  window.hook('IPFS');
}
<strong>
</strong><strong>// worker not ready to receive postMessage
</strong>// IndexedDB might have the content
document.addEventListener('dbReady', listener, false);

// node ready to fetch
document.addEventListener('nodeReady', listener, false);
</code></pre>

You can also have text containers. They work the same way as images as shown on the example below:

```html
// Get data as Blob

<pre class="Bloqcoin" type="blob" data-src="txids" data-mimetype="text/plain"></pre>

// Retrieve data Chunked

<pre class="Bloqcoin" type="chunk" data-src="txids" data-mimetype="text/plain"></pre>
```

### HEAD

The HTTP HEAD method requests the headers that would be returned if the HEAD request's URL was instead requested with the HTTP GET method.

For example, if a request might produce a large download, a `HEAD` request could read its [`Content-Length`](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Length) header to check the file-size without actually downloading the file.

## Retrieve blob headers

`HEAD` `https://api.bloqifi.com/v0/blob/OBJECTID`

Retrieve a blob's headers

{% tabs %}
{% tab title="200: OK " %}

```
'Content-Type': mimetype,
'Content-Length': hexSize
```

{% endtab %}

{% tab title="404: Not Found " %}

{% endtab %}
{% endtabs %}

### Fetch blob from IPFS

The Blob object represents a blob, which is a file-like object of immutable, raw data; they can be read as text or binary data, or converted into a `ReadableStream` so its methods can be used for processing the data.

## Retrieve blob

<mark style="color:blue;">`GET`</mark> `https://storage.bloqifi.com/ipfs/CID`

Retrieve a blob

{% tabs %}
{% tab title="200: OK " %}

```
Returns plain raw data which contains
a concatenation of the cid passed into the constructor.
```

{% endtab %}
{% endtabs %}

## Retrieve hex string

<mark style="color:blue;">`GET`</mark> `https://storage.bloqifi.com/ipfs/hex/CID`

Retrieve a hex string

{% tabs %}
{% tab title="200: OK " %}

```
Returns hex string from IPFS data
```

{% endtab %}
{% endtabs %}


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.bloqifi.com/reference/retrieval/blob.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.