The Global Full-Stack Platform for Apps and APIs

Everything developers need to build performant apps on the edge and beyond

Create a Free Developer Account

Request a Demo

What is Macrometa?

The Developer Platform for the Edge

Macrometa is a secure, global data platform with integrated pub/sub, stream processing, search, functions, and containers. Create stateful APIs and real-time, event-driven, streaming data apps in minutes – not months.

Think Locally, Deploy Globally

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

4 Databases in One

Use Macrometa as a key-value store, a document database, a graph database, and as a streaming database.

Complete Stream Processing

Build event-driven apps with real-time pub/sub, message queues, and a complex event processing engine.

Ultra Low-Latency

<50ms P90 round-trip request latency, from the client to our cloud/edge regions and back again.

Real-Time Search on Data

Add indexes and views to create semantic search across all data stores automatically (not Elastic-ally).

Global Data and API Caching

Make your apps up to 100x faster with coordination-free, geo-replicated cache on our Global Data Network.

Unleash Developer Velocity

Build lightning-fast, fully-distributed apps and services with our robust 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. No DevOps required.


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

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

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

View on GitHub


from c8 import C8Client

fed_url = "gdn.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))

View on GitHub


gdnsl collection create employees --type doc --stream


const jsc8 = require("jsc8");
const client = new jsc8({
  url: "https://gdn.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);
})();

View on GitHub


from c8 import C8Client
fed_url = "gdn.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()))

View on GitHub


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

View on GitHub


const jsc8 = require("jsc8");
const client = new jsc8({
  url: "https://gdn.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!");
})();

View on GitHub


from c8 import C8Client

fed_url = "gdn.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"

View on GitHub


const jsc8 = require("jsc8");
const client = new jsc8({
  url: "https://gdn.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();
})();

View on GitHub


from c8 import C8Client
import json
import requests

fed_url = "gdn.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)

View on GitHub


gdnsl streams list

Quickstart Guide

Sample Apps

Blazing Fast, Everywhere on the Planet

Macrometa lets you store, serve, and process your data within 10ms 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 Easy

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.

Schedule a Demo

“Macrometa has some hardcore computer science behind it.”

James Governor
Cofounder, Redmonk

“Macrometa is becoming the de facto edge provider to run data-heavy and compute-intensive workloads for developers and enterprises alike. We take pride in partnering with the Macrometa team.”

Chris Cooper
General Partner, Pelion

“I like products that make their users heroes, and Macrometa does just that. It makes me proud to be a Board of Directors member.”

Jon Gelsey
Former CEO, Auth0 & XNOR.AI