The Edge Platform for Enterprise Developers

Store, process, and serve data within milliseconds of everyone on the planet.

Trusted at scale

Build real-time apps and APIs in minutes – not months

Macrometa is a Global Data Network offering a Global Data Mesh, Edge Compute, and Data Protection. Build and run applications all over the world with a single copy of data.

Think Locally, Deploy Globally

Macrometa is globally-distributed with over 175 PoPs around the world.

4 Databases in One

Multi-model data layer for key-value, document, graph, and streaming data.

Complete Stream Processing

Complex Event Processing engine with pub/sub, message queues, and more.

Ultra-Low Latency

<50ms P90 round-trip request latency, for both reads and writes.

Real-Time Search on Data

Flexible full-text search and similarity ranking across multiple data stores.

Global Data and API Caching

Make your apps up to 100x faster with geo-replicated edge caching.

Zero-config required

Fast, global apps and services with just an API and a few lines of code. Forget about infrastructure and focus on shipping products and features in a fraction of the time.

You write the code, we’ll make it fast.

const jsc8 = require("jsc8");
const client = new jsc8({
  url: "https://api-play.paas.macrometa.io",
  apiKey: "XXXX"
});

(async () =>{
  const collection = await client.createCollection("employees", {
    stream: true
  });

  console.log("Collection created", collection);
})();

Read the docs

from c8 import C8Client

fed_url = "api-play.paas.macrometa.io"
guest_mail = "[email protected]"
guest_password = "xxxxxx"

geo_fabric = "_system"
collection_name = "employees"

if __name__ == '__main__':
    print("\n ------- CONNECTION SETUP  ------")
    print("tenant: {}, geofabric:{}".format(guest_mail, geo_fabric))
    client = C8Client(protocol='https', host=fed_url, port=443,
                      email=guest_mail, password=guest_password,
                      geofabric=geo_fabric)

    print("\n ------- CREATE GEO-REPLICATED COLLECTION  ------")
    if client.has_collection(collection_name):
        print("Collection exists")
    else:
        employees = client.create_collection(collection_name)
        print("Created collection: {}".format(collection_name))

Read the docs

gdnsl collection create employees --type doc --stream


const jsc8 = require("jsc8");
const client = new jsc8({
  url: "https://api-play.paas.macrometa.io/",
  apiKey: "XXXX"
});

(async () => {
    const record = "INSERT { 'firstname': @firstname, 'lastname': @lastname, 'email': @email, 'zipcode': @zipcode, '_key': @email } IN employees";
    const queryWorker = await client.createRestql("insertRecord", record, {});

    console.log("Created query worker!", queryWorker);
})();

Read the docs


from c8 import C8Client
fed_url = "api-play.paas.macrometa.io"
guest_mail = "[email protected]"
guest_password = "xxxxxx"

geo_fabric = "_system"
collection_name = "employees"

value = "INSERT {'firstname':@firstname, 'lastname':@lastname, 'email':@email, 'zipcode':@zipcode, '_key': 'abc'} IN %s" % collection_name
parameter = {"firstname": "", "lastname": "", "email": "", "zipcode": ""}

insert_data = {"query": {"name": "insertRecord",
                         "parameter": parameter, "value": value}}

if __name__ == '__main__':

    print("\n ------- CONNECTION SETUP  ------")
    print("tenant: {}, geofabric:{}".format(guest_mail, geo_fabric))
    client = C8Client(protocol='https', host=fed_url, port=443,
                      email=guest_mail, password=guest_password,
                      geofabric=geo_fabric)

    print("\n ------- CREATE QUERY WORKER  ------")
    client.create_restql(insert_data)  # name: insertRecord
    print("Created RESTQLs:{}".format(client.get_restqls()))

Read the docs


gdnsl query-worker create insertData --value "INSERT {'firstname':@firstname, 'lastname':@lastname, 'email':@email, 'zipcode':@zipcode} IN employees"

Read the docs


const jsc8 = require("jsc8");
const client = new jsc8({
  url: "https://api-play.paas.macrometa.io",
  apiKey: "XXXX"
});

(async () => {
    const record = {
      "firstname": "john", 
      "lastname": "doe",
      "email": "[email protected]", 
      "zipcode": "511037"
    };

    await client.executeRestql("insertRecord", record);

    console.log("Data inserted into query worker!");
})();

Read the docs


from c8 import C8Client

fed_url = "api-play.paas.macrometa.io"
guest_mail = "[email protected]"
guest_password = "xxxxxx"
geo_fabric = "_system"
collection_name = "employees"

if __name__ == '__main__':

    print("\n ------- CONNECTION SETUP  ------")
    print("tenant: {}, geofabric:{}".format(guest_mail, geo_fabric))
    client = C8Client(protocol='https', host=fed_url, port=443,
                      email=guest_mail, password=guest_password,
                      geofabric=geo_fabric)

    print("\n ------- EXECUTE RESTQLs ------")
    print("Insert data....")
    response = client.execute_restql(
        "insertRecord",
        {"bindVars": {"firstname": "john", "lastname": "doe",
                      "email": "[email protected]", "zipcode": "511037"}})


gdnsl query-worker run insertData --param "firstname=john" "lastname=doe" "[email protected]" "zipcode=94002"

Read the docs


const jsc8 = require("jsc8");
const client = new jsc8({
  url: "https://api-play.paas.macrometa.io",
  apiKey: "XXXX"
});

(async () => {
  const realtimeListener = async () => {
    const listener = await client.onCollectionChange("employees");

    listener.on('message', (ent) => {
      console.log("Event =>", msg);
    });

    listener.on('open', () => {
      console.log("Connection open...")
    });

    listener.on('close', () => {
      console.log("Connection closed!")
    });
  }

  await realtimeListener();
})();

Read the docs


from c8 import C8Client
import json
import requests

fed_url = "api-play.paas.macrometa.io"
guest_mail = "[email protected]"
guest_password = "xxxxxx"
geo_fabric = "_system"
collection_name = "employees"

def get_auth_token(email, password):
    data = {
            "email": email,
            "password": password,
    }
    data = json.dumps(data)
    url = f"https://api-{fed_url}/_open/auth"
    response = requests.post(url, data=data)
    if response.status_code == 200:
        body = json.loads(response.text)
        token = body.get("jwt")
        if (not token):
            print("Failed to get Authentication Token for URL: {},Email: {}".format(url, email))
    else:
        print("Failed to Authenticate the C8DB user for URL: {} and Email: {}. Error: {}".format(url, email, response.text))
        
    return token

def enable_collection_stream(token, fabricName, collectionName):
    data = { 
            "hasStream": True
    }
    data = json.dumps(data)
    url = f"https://api-{fed_url}/_fabric/{fabricName}/_api/collection/{collectionName}/properties"
    jwtToken = f"bearer {token}"   
    headers={'Authorization': jwtToken, 'accept' : "application/json" }
    response = requests.put(url, data=data, headers=headers)
    if response.status_code == 200:
        print("Enabled stream for collection: {}".format(collection_name))
    else:
        print("Failed to enable the stream for collection: {}, Error: {}".format(collection_name, response.status_code))
        
def callback_fn(event):
    print(event)
    
if __name__ == '__main__':
    print("tenant: {}, geofabric:{}".format(guest_mail, geo_fabric))
    token = get_auth_token(guest_mail, guest_password)    

    enable_collection_stream(token, geo_fabric, collection_name)
    
    # Get the C8DBClient object
    client = C8Client(protocol='https', host=fed_url, port=443,
                  email=guest_mail, password=guest_password,
                  geofabric=geo_fabric)
    
    # Subscribe to the stream
    client.on_change("employees", callback=callback_fn)

Read the docs


gdnsl streams list

Quickstart Guide

Sample Apps

Blazing Fast, Everywhere on the Planet

Macrometa lets you store, serve, and process your data within 50ms of 80% of the global population.

Up to 100x Faster at 1/10th the Cost

Built from the ground up to be dramatically faster and more efficient than conventional cloud providers, allowing us to pass those savings directly to our customers.

Learn more

Data Governance Made Easier

We allow you to improve performance, user experience, and comply with global data governance laws. Physically pin data to specific regions and tokenize it for access externally.

Learn more

Trusted by Enterprise

For ultimate scalability, growth, and efficiency, these enterprises choose Macrometa. Create the ultimate customer experience with stateful data and real-time analytics – at a fraction of the cost.

Learn about Macrometa for Enterprise

Macrometa has obtained a SOC 2 Type 2 certification for the Trust Criteria of Security and Availability.

The SOC 2 report is available under NDA for Macrometa customers by request at [email protected]

“Macrometa has some hardcore computer science behind it.”

James Governor
Co-founder
Redmonk

“After trying many different services I landed on Macrometa. The low latency won me over, and the ease of use, fair pricing, and friendly staff made me stay. Super easy to get started and I haven't worried about it since. It just works.”

Dominik Ferber
‍Founder
HappyKit

"Macrometa makes navigating our website feel instantaneous from anywhere in the world, even when there are highly complex queries being run in order to serve and process the financial data in real-time."

Kris Gunnars
‍Founder & CEO
Stock Analysis

The Edge Platform for Enterprise Developers

Trusted at scale

Build real-time apps and APIs in minutes – not months

Think Locally, Deploy Globally

4 Databases in One

Complete Stream Processing

Ultra-Low Latency

Real-Time Search on Data

Global Data and API Caching

Zero-config required

Blazing Fast, Everywhere on the Planet

Trusted by Enterprise

Quickstart Guide

Developer Tools

API Reference