Overview

The View BLOB (Binary Large Object) management system provides comprehensive storage and retrieval capabilities for unstructured data objects. BLOBs serve as flexible containers for various types of content including files, configurations, and binary data within the View platform.

Key Features

Flexible Storage: Store any type of binary or text data with automatic content type detection
Metadata Management: Rich metadata support including descriptions, references, and custom properties
Security Controls: Public/private access controls and tenant isolation
Data Integrity: Built-in hash verification (MD5, SHA1, SHA256) for data integrity
Reference System: Link BLOBs to other objects in the system for organized data management
Multi-format Support: Support for various content types and data formats

Supported Operations

Create: Upload new BLOB objects with metadata
Read: Retrieve BLOB metadata and data
Update: Modify existing BLOB properties and content
Delete: Remove BLOB objects from storage
Enumerate: List and search BLOB objects
Existence Check: Verify BLOB presence without downloading data

API Endpoints

BLOBs are managed via the Configuration server API at [http|https]://[hostname]:[port]/v1.0/tenants/[tenant-guid]/blobs

Supported HTTP Methods: GET, HEAD, PUT, DELETE

BLOB Object Structure

BLOB objects contain comprehensive metadata and data information. Here's the complete structure:

{
    "GUID": "c3c8b73d-859b-48a2-bfaf-511e83423585",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "ContentType": "application/json",
    "Name": "botox",
    "Description": "My botox AI assistant",
    "Url": "./blobs/default",
    "Length": 1276,
    "RefObjType": "assistant_config",
    "RefObjGUID": "[default]",
    "IsPublic": false,
    "MD5Hash": "851F017BDA502D5289FB9CC0E329F4",
    "SHA1Hash": "DC0E2BB71821F82DF10EBD8D135F9487BAAC9E",
    "SHA256Hash": "E27C697760B5C434079F0F82D52AFD3DBBFFC33B19453B2F10A3C736DC1D",
    "CreatedUtc": "2025-03-25T21:32:33.971195Z"
}

Field Descriptions

GUID (GUID): Globally unique identifier for the BLOB object
TenantGUID (GUID): Globally unique identifier for the tenant
ContentType (string): MIME type of the BLOB content
Name (string): Display name of the BLOB object
Description (string): Human-readable description of the BLOB
Url (string): Relative URL path for accessing the BLOB
Length (integer): Size of the BLOB data in bytes
RefObjType (string): Type of the referenced object (e.g., "assistant_config")
RefObjGUID (string): GUID of the referenced object
IsPublic (boolean): Whether the BLOB is publicly accessible
MD5Hash (string): MD5 hash of the BLOB data for integrity verification
SHA1Hash (string): SHA1 hash of the BLOB data for integrity verification
SHA256Hash (string): SHA256 hash of the BLOB data for integrity verification
CreatedUtc (datetime): UTC timestamp when the BLOB was created

Create BLOB

Creates a new BLOB object with specified metadata and data using PUT /v1.0/tenants/[tenant-guid]/blobs. This endpoint allows you to upload binary or text data with comprehensive metadata.

Request Parameters

ContentType (string, Body, Required): MIME type of the content (e.g., "text/plain", "application/json")
Name (string, Body, Required): Display name for the BLOB object
Description (string, Body, Optional): Human-readable description of the BLOB
RefObjType (string, Body, Required): Type of the referenced object (use "[usermanaged]" for user-managed BLOBs)
RefObjGUID (string, Body, Required): GUID of the referenced object (use "[usermanaged]" for user-managed BLOBs)
Data (string, Body, Required): Base64-encoded data content

curl --location --request PUT 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs' \
--header 'content-type: application/json' \
--header 'Authorization: ••••••' \
--data '{
    "ContentType": "text/plain",
    "Name": "helloworld.txt",
    "Description": "A text file containing '\''Hello, world!'\''",
    "RefObjType": "[usermanaged]",
    "RefObjGUID": "[usermanaged]",
    "Data": "SGVsbG8sIHdvcmxkIQ=="
}'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const createBlob = async () => {
  try {
    const response = await api.Blob.create({
      ContentType: "text/plain",
      Name: "helloworld.txt",
      Description: "A text file containing 'Hello, world!'",
      RefObjType: "[usermanaged]",
      RefObjGUID: "[usermanaged]",
      Data: "SGVsbG8sIHdvcmxkIQ==",
    });
    console.log(response, "Blob created successfully");
  } catch (err) {
    console.log("Error creating blob:", err);
  }
};

createBlob();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def createBlob():
    blob = configuration.Blob.create(
        ContentType="text/plain",
        Name="helloworld.txt",
        Description="A text file containing 'Hello, world!'",
        RefObjType="[usermanaged]",
        RefObjGUID="[usermanaged]",
        Data="SGVsbG8sIHdvcmxkIQ=="
    )
    print(blob)

createBlob()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://locahost:8000/");
            
Blob request = new Blob
{
    ContentType = "text/plain",
    Name = "helloworld.txt",
    Description = "A text file containing 'Hello, world!'",
    RefObjType = "[usermanaged]",
    RefObjGUID = "[usermanaged]",
    Data = Convert.FromBase64String("SGVsbG8sIHdvcmxkIQ==")
};

Blob response = await sdk.Blob.Create(request);

Response

Returns the created BLOB object with metadata and hash values:

{
    "GUID": "c3c8b73d-859b-48a2-bfaf-511e83423585",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "ContentType": "text/plain",
    "Name": "helloworld.txt",
    "Description": "A text file containing 'Hello, world!'",
    "Url": "./blobs/c3c8b73d-859b-48a2-bfaf-511e83423585",
    "Length": 13,
    "RefObjType": "[usermanaged]",
    "RefObjGUID": "[usermanaged]",
    "IsPublic": false,
    "MD5Hash": "851F017BDA502D5289FB9CC0E329F4",
    "SHA1Hash": "DC0E2BB71821F82DF10EBD8D135F9487BAAC9E",
    "SHA256Hash": "E27C697760B5C434079F0F82D52AFD3DBBFFC33B19453B2F10A3C736DC1D",
    "CreatedUtc": "2025-03-25T21:32:33.971195Z"
}

Enumerate BLOBs

Retrieves a list of all BLOB objects in the tenant using GET /v2.0/tenants/[tenant-guid]/blobs. This endpoint provides paginated results with comprehensive metadata for each BLOB.

Request Parameters

No additional parameters required beyond authentication.

curl --location 'http://localhost:8000/v2.0/tenants/00000000-0000-0000-0000-000000000000/blobs' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);


const enumerateBlobs = async () => {
  try {
    const response = await api.Blob.enumerate();
    console.log(response, "Blobs fetched successfully");
  } catch (err) {
    console.log("Error fetching Blobs:", err);
  }
};

enumerateBlobs();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def enumerateBlobs():
    blobs = configuration.Blob.enumerate()
    print(blobs)

enumerateBlobs()

using View.Sdk;
using View.Sdk.Configuration;


ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
EnumerationResult<Blob> response = await sdk.Blob.Enumerate();

Response

Returns a paginated list of BLOB objects:

{
    "Success": true,
    "Timestamp": {
        "Start": "2024-10-21T02:36:37.677751Z",
        "TotalMs": 23.58,
        "Messages": {}
    },
    "MaxResults": 10,
    "IterationsRequired": 1,
    "EndOfResults": true,
    "RecordsRemaining": 0,
    "Objects": [
        {
            "GUID": "c3c8b73d-859b-48a2-bfaf-511e83423585",
            "TenantGUID": "00000000-0000-0000-0000-000000000000",
            "ContentType": "text/plain",
            "Name": "helloworld.txt",
            "Description": "A text file containing 'Hello, world!'",
            "Url": "./blobs/c3c8b73d-859b-48a2-bfaf-511e83423585",
            "Length": 13,
            "RefObjType": "[usermanaged]",
            "RefObjGUID": "[usermanaged]",
            "IsPublic": false,
            "MD5Hash": "851F017BDA502D5289FB9CC0E329F4",
            "SHA1Hash": "DC0E2BB71821F82DF10EBD8D135F9487BAAC9E",
            "SHA256Hash": "E27C697760B5C434079F0F82D52AFD3DBBFFC33B19453B2F10A3C736DC1D",
            "CreatedUtc": "2025-03-25T21:32:33.971195Z"
        }
    ],
    "ContinuationToken": null
}

Read BLOB

Retrieves BLOB metadata by GUID using GET /v1.0/tenants/[tenant-guid]/blobs/[blob-guid]. Returns the BLOB object metadata without the actual data content. If the object doesn't exist, a 404 error is returned.

Request Parameters

blob-guid (string, Path, Required): GUID of the BLOB object to retrieve

curl --location 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);
const readBlob = async () => {
  try {
    const response = await api.Blob.read(
      "431638f9-1da1-4dd2-b6de-e88acf990c8c"
    );
    console.log(response, "Blob read successfully");
  } catch (err) {
    console.log("Error reading Blob:", err);
  }
};

readBlob();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def readBlob():
    blob = configuration.Blob.retrieve("blob-guid")
    print(blob)

readBlob()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
Blob response = await sdk.Blob.Retrieve(Guid.Parse("<blob-guid>"));

Response

Returns the BLOB metadata without data content:

{
    "GUID": "c3c8b73d-859b-48a2-bfaf-511e83423585",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "ContentType": "text/plain",
    "Name": "helloworld.txt",
    "Description": "A text file containing 'Hello, world!'",
    "Url": "./blobs/c3c8b73d-859b-48a2-bfaf-511e83423585",
    "Length": 13,
    "RefObjType": "[usermanaged]",
    "RefObjGUID": "[usermanaged]",
    "IsPublic": false,
    "MD5Hash": "851F017BDA502D5289FB9CC0E329F4",
    "SHA1Hash": "DC0E2BB71821F82DF10EBD8D135F9487BAAC9E",
    "SHA256Hash": "E27C697760B5C434079F0F82D52AFD3DBBFFC33B19453B2F10A3C736DC1D",
    "CreatedUtc": "2025-03-25T21:32:33.971195Z"
}

Read Public BLOB

Retrieves public BLOB metadata by GUID using GET /v1.0/tenants/[tenant-guid]/blobs/public/[blob-guid]. This endpoint allows access to BLOB objects that have been marked as public, without requiring authentication tokens.

Request Parameters

blob-guid (string, Path, Required): GUID of the public BLOB object to retrieve

curl --location 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs/public/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const readPublicBlob = async () => {
  try {
    const response = await api.Blob.readPublicBlob(
      "<blob-buid>"
    );
    console.log(response, "Public blob read successfully");
  } catch (err) {
    console.log("Error reading public blob:", err);
  }
};

readPublicBlob();

Read BLOB with Data

Retrieves BLOB metadata and data content by GUID using GET /v1.0/tenants/[tenant-guid]/blobs/[blob-guid]?incldata=null. This endpoint returns both the BLOB metadata and the actual data content.

Request Parameters

blob-guid (string, Path, Required): GUID of the BLOB object to retrieve
incldata (string, Query, Required): Set to "null" to include data content

curl --location 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs/00000000-0000-0000-0000-000000000000?incldata=null' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const readBlobWithData = async () => {
  try {
    const response = await api.Blob.readIncludeData(
      "431638f9-1da1-4dd2-b6de-e88acf990c8c"
    );
    console.log(response, "Blob read successfully");
  } catch (err) {
    console.log("Error reading Blob:", err);
  }
};

readBlobWithData();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def readBlob():
    blob = configuration.Blob.retrieve("blob-guid",True)
    print(blob)

readBlob()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
bool inclData = true;
Blob response = await sdk.Blob.Retrieve((Guid.Parse("<blob-guid>"),inclData);

Response

Returns the BLOB metadata with data content:

{
    "GUID": "c3c8b73d-859b-48a2-bfaf-511e83423585",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "ContentType": "text/plain",
    "Name": "helloworld.txt",
    "Description": "A text file containing 'Hello, world!'",
    "Url": "./blobs/c3c8b73d-859b-48a2-bfaf-511e83423585",
    "Length": 13,
    "RefObjType": "[usermanaged]",
    "RefObjGUID": "[usermanaged]",
    "IsPublic": false,
    "MD5Hash": "851F017BDA502D5289FB9CC0E329F4",
    "SHA1Hash": "DC0E2BB71821F82DF10EBD8D135F9487BAAC9E",
    "SHA256Hash": "E27C697760B5C434079F0F82D52AFD3DBBFFC33B19453B2F10A3C736DC1D",
    "Data": "SGVsbG8sIHdvcmxkIQ==",
    "CreatedUtc": "2025-03-25T21:32:33.971195Z"
}

Read All BLOBs

Retrieves all BLOB objects in the tenant using GET /v1.0/tenants/[tenant-guid]/blobs/. Returns an array of BLOB objects with metadata (without data content) for all BLOBs in the tenant.

Request Parameters

No additional parameters required beyond authentication.

curl --location 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const readAllBlobs = async () => {
  try {
    const response = await api.Blob.readAll();
    console.log(response, "All blobs fetched successfully");
  } catch (err) {
    console.log("Error fetching All blobs:", err);
  }
};

readAllBlobs();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def readAllBlobs():
    blobs = configuration.Blob.retrieve_all()
    print(blobs)

readAllBlobs()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");
            
List<Blob> response = await sdk.Blob.RetrieveMany();

Response

Returns an array of all BLOB objects:

[
    {
        "GUID": "c3c8b73d-859b-48a2-bfaf-511e83423585",
        "TenantGUID": "00000000-0000-0000-0000-000000000000",
        "ContentType": "text/plain",
        "Name": "helloworld.txt",
        "Description": "A text file containing 'Hello, world!'",
        "Url": "./blobs/c3c8b73d-859b-48a2-bfaf-511e83423585",
        "Length": 13,
        "RefObjType": "[usermanaged]",
        "RefObjGUID": "[usermanaged]",
        "IsPublic": false,
        "MD5Hash": "851F017BDA502D5289FB9CC0E329F4",
        "SHA1Hash": "DC0E2BB71821F82DF10EBD8D135F9487BAAC9E",
        "SHA256Hash": "E27C697760B5C434079F0F82D52AFD3DBBFFC33B19453B2F10A3C736DC1D",
        "CreatedUtc": "2025-03-25T21:32:33.971195Z"
    },
    {
        "GUID": "another-blob-guid",
        "TenantGUID": "00000000-0000-0000-0000-000000000000",
        "ContentType": "application/json",
        "Name": "config.json",
        "Description": "Configuration file",
        "Url": "./blobs/another-blob-guid",
        "Length": 256,
        "RefObjType": "assistant_config",
        "RefObjGUID": "default",
        "IsPublic": false,
        "MD5Hash": "A1B2C3D4E5F6789012345678901234567",
        "SHA1Hash": "1234567890ABCDEF1234567890ABCDEF12345678",
        "SHA256Hash": "1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF1234567890ABCDEF",
        "CreatedUtc": "2025-03-25T22:15:45.123456Z"
    }
]

Update BLOB

Updates an existing BLOB object with new metadata and data using PUT /v1.0/tenants/[tenant-guid]/blobs/{blob-guid}. This endpoint allows you to modify BLOB properties and content.

Request Parameters

blob-guid (string, Path, Required): GUID of the BLOB object to update
ContentType (string, Body, Required): MIME type of the content
Name (string, Body, Required): Display name for the BLOB object
Description (string, Body, Optional): Human-readable description of the BLOB
RefObjType (string, Body, Required): Type of the referenced object
RefObjGUID (string, Body, Required): GUID of the referenced object
Data (string, Body, Required): Base64-encoded data content

curl --location --request PUT 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs/00000000-0000-0000-0000-000000000000' \
--header 'content-type: application/json' \
--header 'Authorization: ••••••' \
--data '{
    "ContentType": "text/plain",
    "Name": "helloworld.txt",
    "Description": "A text file containing '\''Hello, world, yet again!'\''",
    "RefObjType": "[usermanaged]",
    "RefObjGUID": "[usermanaged]",
    "Data": "SGVsbG8sIHdvcmxkLCB5ZXQgYWdhaW4h"
}'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const updateBlob = async () => {
  try {
    const response = await api.Blob.update({
      GUID: "7f6eee35-fc32-4798-8ea7-e9e84775043e",
      ContentType: "text/plain",
      Name: "helloworldASH[UPDATED].txt",
      Description: "A text file containing 'Hello, world!'",
      RefObjType: "[usermanaged]",
      RefObjGUID: "[usermanaged]",
      Data: "SGVsbG8sIHdvcmxkIQ==",
    });
    console.log(response, "Blob updated successfully");
  } catch (err) {
    console.log("Error updating Blob:", err);
  }
};

updateBlob();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def updateBlob():
    blob = configuration.Blob.update("b1a953d8-2a51-496a-a272-52ebe326fd2d",
       ContentType="text/plain",
        Name="helloworld_updated.txt",
        Description="A text file containing 'Hello, world!'",
        RefObjType="[usermanaged]",
        RefObjGUID="[usermanaged]",
        Data="SGVsbG8sIHdvcmxkIQ=="
    )
    print(blob)

updateBlob()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://locahost:8000/");
            
Blob request = new Blob
{
    GUID = Guid.Parse("<blob-guid>"),
    TenantGUID = Guid.Parse("<tenant-guid>"),
    ContentType = "text/plain",
    Name = "helloworld.txt",
    Description = "A text file containing 'Hello, world!'",
    RefObjType = "[usermanaged]",
    RefObjGUID = "[usermanaged]",
    Data = Convert.FromBase64String("SGVsbG8sIHdvcmxkIQ==")
};

Blob response = await sdk.Blob.Update(request);

Response

Returns the updated BLOB object with metadata and hash values:

{
    "GUID": "c3c8b73d-859b-48a2-bfaf-511e83423585",
    "TenantGUID": "00000000-0000-0000-0000-000000000000",
    "ContentType": "text/plain",
    "Name": "helloworld.txt",
    "Description": "A text file containing 'Hello, world!'",
    "Url": "./blobs/c3c8b73d-859b-48a2-bfaf-511e83423585",
    "Length": 13,
    "RefObjType": "[usermanaged]",
    "RefObjGUID": "[usermanaged]",
    "IsPublic": false,
    "MD5Hash": "851F017BDA502D5289FB9CC0E329F4",
    "SHA1Hash": "DC0E2BB71821F82DF10EBD8D135F9487BAAC9E",
    "SHA256Hash": "E27C697760B5C434079F0F82D52AFD3DBBFFC33B19453B2F10A3C736DC1D",
    "CreatedUtc": "2025-03-25T21:32:33.971195Z"
}

Delete BLOB

Deletes a BLOB object by GUID using DELETE /v1.0/tenants/[tenant-guid]/blobs/[blob-guid]. This operation permanently removes the BLOB and its data from storage.

Request Parameters

blob-guid (string, Path, Required): GUID of the BLOB object to delete

curl --location --request DELETE 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••' \

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);
const deleteBlob = async () => {
  try {
    const response = await api.Blob.delete(
      "7f6eee35-fc32-4798-8ea7-e9e84775043e"
    );
    console.log(response, "Blob deleted successfully");
  } catch (err) {
    console.log("Error deleting Blob:", err);
  }
};

deleteBlob();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def deleteBlob():
    blob = configuration.Blob.delete("b1a953d8-2a51-496a-a272-52ebe326fd2d")
    print(blob)

deleteBlob()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");

bool deleted = await sdk.Blob.Delete(Guid.Parse("<blob-guid>"));

Response

Returns 204 No Content on successful deletion. No response body is returned.

Check BLOB Existence

Verifies if a BLOB object exists without downloading its content using HEAD /v1.0/tenants/[tenant-guid]/blobs/[blob-guid]. This is an efficient way to check BLOB presence before performing operations.

Request Parameters

blob-guid (string, Path, Required): GUID of the BLOB object to check

curl --location --head 'http://localhost:8000/v1.0/tenants/00000000-0000-0000-0000-000000000000/blobs/00000000-0000-0000-0000-000000000000' \
--header 'Authorization: ••••••'

import { ViewConfigurationSdk } from "view-sdk";

const api = new ViewConfigurationSdk(
  "http://localhost:8000/", //endpoint
  "default", //tenant Id
  "default" //access key
);

const blobExists = async () => {
  try {
    const response = await api.Blob.exists(
      "431638f9-1da1-4dd2-b6de-e88acf990c8c"
    );
    console.log(response, "Blob exists");
  } catch (err) {
    console.log("Error checking Blob:", err);
  }
};

blobExists();

import view_sdk
from view_sdk import configuration
from view_sdk.sdk_configuration import Service

sdk = view_sdk.configure(
    access_key="default",
    base_url="localhost", 
    tenant_guid="default",
    service_ports={Service.DEFAULT: 8000},
)

def existsBlob():
    blob = configuration.Blob.exists("b1a953d8-2a51-496a-a272-52ebe326fd2d")
    print(blob)

existsBlob()

using View.Sdk;
using View.Sdk.Configuration;

ViewConfigurationSdk sdk = new ViewConfigurationSdk(Guid.Parse("<tenant-guid>"),"default", "http://localhost:8000/");

bool exists = await sdk.Blob.Exists(Guid.Parse("<blob-guid>"));

Response

200 No Content: BLOB exists
404 Not Found: BLOB does not exist
No response body: Only HTTP status code is returned

Note: HEAD requests do not return a response body, only the HTTP status code indicating whether the BLOB exists.

Best Practices

When working with BLOB objects in the View platform, consider the following recommendations:

Data Encoding: Always encode binary data as Base64 when uploading to ensure proper transmission
Content Types: Set appropriate MIME types for better content handling and validation
Data Integrity: Verify hash values (MD5, SHA1, SHA256) for critical data integrity checks
Efficient Operations: Use HEAD requests to check existence before downloading large BLOBs
Security: Be mindful of IsPublic settings and tenant isolation for sensitive data

Next Steps

After successfully managing BLOB objects, you can:

Integrate with Applications: Use BLOB data in your applications and workflows
Implement File Management: Build file upload/download interfaces using BLOB operations
Data Processing: Process BLOB content for analysis, transformation, or reporting
Content Delivery: Use BLOB URLs for content delivery in web applications
API Integration: Integrate BLOB operations with other View platform APIs