BathTimeFish, K.K.
KrakenOSS 日本語

Open SourceIoT Data Router

IoT, Smaller
and Freer.

The right choice for environments where cloud IoT feels too heavy.

Kraken is an open-source IoT data router that combines Kraken Collector and Kraken Broker to flexibly build workflows for IoT data collection, processing, storage, and notification.

From small environments like Raspberry Pi to scalable container-based deployments, it grows with your needs and budget. While large-scale cloud IoT platforms have their place, Kraken is the practical alternative for teams who want to start smaller and more freely.

View on GitHub Consult regarding Implementation
  • LicenseMIT
  • CollectorRust
  • BrokerPython
  • TransportgRPC
  • Runs onRaspberry Pi to containers
Data flows from Sensors, Devices and Apps into Kraken Collector, over gRPC to Kraken Broker, and on to DB, Notification and Apps Sensors Devices External Apps gRPC Kraken Collector Rust Kraken Broker Python DB Notification Apps

Devices / Sensors → Kraken Collector → gRPC → Kraken Broker → DB / Notification / Apps

For environments where cloud IoT is a bit too much.

You want to start IoT, but the architecture becomes too heavy when including cloud, apps, and operations platforms.
This dilemma is common for companies pushing for field-driven IoT or teams looking to start with a small PoC.

Cost & Lock-in

Desire to minimize subscription costs. Reluctance to rely solely on cloud-first architectures.

On-Premises Focus

Need to manage all resources locally within the operational field or closed network.

Minimal Requirements

Want to start small without over-engineering. Preferring the ability to quickly build necessary functions over having excessive features.

Kraken was born from this background. While feature-rich cloud IoT platforms are necessary for some projects, many environments prioritize operational cost, data ownership, and compact configurations. Kraken is developed to let you "start IoT small" in exactly these scenarios.

Simplifying the IoT data flow from collection to processing.

Kraken is a two-layer IoT backend. The Collector receives data from diverse protocols and sources, and the Broker connects that data to processing, storage, notifications, and external systems.
Pick an input and an output to sketch the setup for your own site.

1Choose an inputCollector

2Choose an outputBroker

HTTP Webhooks → Collector → Broker → Slack 

                    
* Illustrates the data flow. Several inputs and outputs can run at the same time.

                


                

                    

                        
Kraken Collector
Rust

                        
A lightweight data collection layer handling diverse inputs.

                        
An application that collects data from edge IoT sensors and peripheral systems. Implemented in Rust, it runs as a lightweight and scalable gRPC client for Kraken Broker. New collectors can be added as needed to extend functionality.

                    

                    

                        
Kraken Broker
Python

                        
A flexible broker layer connecting received data to business logic.

                        
A data broker that receives data from the Collector and executes custom processing such as transformation, storage, and notifications. Necessary operations can be written as brokers and executed asynchronously via events. Currently available in Python, chosen for its rich ecosystem of data-analysis libraries, including machine learning, and for how concisely processing can be written.

                    

                

            

        


        
        

            

                
Your first data in three steps.

                
Start the Broker, start the Collector, send one record with curl. That is all it takes to get a Slack notification.
The steps are taken straight from the README.


                

                    

                        
1
Start the Broker
Python

                        
Runs as a Slack broker. Replace the webhook URL with your own Slack webhook.

                        

                            

# clone
git clone https://github.com/bathtimefish/kraken_broker_python
cd kraken_broker_python

# configure as a Slack broker
export PYTHONDONTWRITEBYTECODE=1
export KRAKENB_DEBUG=1
export KRAKENB_GRPC_HOST=[::]:50051
export KRAKENB_SLACK_URL=[YOUR_SLACK_WEBHOOK_URL]

python ./src/main.py

                        

                        
Startup log
INFO:root:gRPC server was started on `[::]:50051`
INFO:root:KRAKEN BROKER is running as debug mode.

                    


                    

                        
2
Start the Collector
Rust

                        
Build and start the Collector as an HTTP webhook receiver.

                        

                            

# clone & build
git clone https://github.com/bathtimefish/kraken_collector
cd kraken_collector
cargo build

# configure as a webhook receiver
export KRKNC_BROKER_HOST=http://[::1]:50051
export KRKNC_WEBHOOK_PATH=webhook
export KRKNC_WEBHOOK_PORT=3000

RUST_LOG=error,main=debug cargo run --bin main

                        

                        
Startup log
[INFO  main] KRAKEN Collector -- The Highlevel Data Collector -- boot sequence start.
[DEBUG main::collectors::webhook] Webhook server was started and is listening on http://0.0.0.0:3000

                    


                    

                        
3
Send data

                        
POST one record with curl in place of a sensor.

                        

                            

curl -X POST -H "Content-Type: application/json" \
  -d '{"id":"101", "name":"env-sensor", "temp":"25.6", "hum":"52.4"}' \
  http://localhost:3000/webhook

                        

                        
Message delivered to Slack
kind=collector, provider=webhook, payload={"id":"101", "name":"env-sensor", "temp":"25.6", "hum":"52.4"}

                    

                


                
Building requires Rust (cargo), Python, and the packages listed in the README (protobuf-compiler and others). See Getting Started on GitHub for details.

            

        


        
        

            

                

                    

                        
Unique to BathTimeFish

                        
Field data from BraveJIG,
straight into your workflow.

                        
BathTimeFish is the developer of Kraken and a BraveJIG integration partner. We provide everything end-to-end, from BraveJIG hardware sales and deployment to acquiring field data and building the utilization platform.

                        
Via the BraveJIG CLI (paid component) provided by BathTimeFish, you can connect BraveJIG sensor data to Kraken Collector, and seamlessly construct pipelines for preprocessing, accumulation, notification, and external integration through Kraken Broker.

                        
It doesn't end with just connecting a sensor. The acquired data must be structured, stored, notified, and passed to external systems for real business use. Data exchange between BraveJIG and your own systems, and data-driven automation that drives equipment from BraveJIG sensor readings, can both be implemented as Kraken Broker processing. By designing not just the data collection but the subsequent steps, we ensure your IoT adoption goes beyond a PoC into actual operations.

                        

                            Consult about BraveJIG × Kraken
                            View BraveJIG CLI
                        

                    

                    

                        
    
                            
  1. 
                                BraveJIG
                                Collect
                                Modular IoT devices that can start from a local LAN
                            
    2. 
                            
  2. 
                                BraveJIG CLI · Paid
                                Connect
                                Provided by BathTimeFish. Sends sensor data to Kraken Collector
                            
    3. 
                            
  3. 
                                Kraken · OSS
                                Leverage
                                Preprocessing, storage, notification, and external integration end to end
                            
    4. 
                        

                        

                            Integration support
                            BathTimeFish provides everything from BraveJIG hardware sales and deployment to Kraken integration and operational design.
                        

                        
* BraveJIG is a modular IoT device series designed for the field, capable of starting from a local LAN without internet access. BathTimeFish, as a BraveJIG integration partner, sells the hardware and supports deployment.

                    

                

            

        


        
        

            

                
Why Choose Kraken

                
    
                    
  • Start Small
    Runs on low-resource environments like Raspberry Pi, allowing you to start IoT small on-premises.
    • 
                    
  • Not Cloud-Dependent
    Does not assume cloud dependency, making it suitable for local fields, closed networks, and dedicated environments.
    • 
                    
  • Build Quickly
    Focuses on letting you quickly build the minimum necessary features for an IoT backend, rather than overwhelming you with unused capabilities.
    • 
                    
  • Broad Input Paths
    Supports diverse field inputs including Webhook, MQTT, BLE, serial, files, camera, email, and TCP.
    • 
                    
  • Freely Extensible
    You can add and customize Collectors and Brokers to fit your specific business logic and field requirements.
    • 
                    
  • Free OSS
    Available for free under an open license, allowing you to develop custom implementations and proprietary operations as needed.
    • 
                

            

        


        
        

            

                
Where Kraken Shines

                

                    

                        
                        
Factory Equipment Monitoring

                        
Collect sensor data, evaluate thresholds in the Broker, and connect to InfluxDB storage and Slack notifications.

                        
Serial / MQTT → InfluxDB + Slack

                    

                    

                        
                        
IoT in Closed Environments

                        
Build Collector/Broker on-premises in sites where cloud adoption is difficult, completing data workflows locally.

                        
Completes inside the closed network

                    

                    

                        
                        
Rapid PoC & Trials

                        
Create a minimal setup on a Raspberry Pi or Mini PC to quickly start collecting and testing data.

                        
From a single Raspberry Pi

                    

                    

                        
                        
Legacy Equipment Connection

                        
Gradually ingest data from existing equipment using serial communication, file monitoring, or TCP servers.

                        
Serial / TextFile / TCP

                    

                    

                        
                        
BLE Beacons & Email Triggers

                        
Handle specialized entry points like iBeacon or SMTP to easily build data integrations matching field needs.

                        
iBeacon / Email

                    

                    

                        
                        
Platform via BraveJIG Sensors

                        
Connect data collected by BraveJIG to Kraken via the BraveJIG CLI to build a full workflow including preprocessing, DB storage, and alerts.

                        
BraveJIG → CLI → Kraken

                    

                


                

                    

                        
Suitable Cases

                        
    
                            
  • Want to start from a small scale
    • 
                            
  • Want to operate on-premises or in closed networks
    • 
                            
  • Need to flexibly configure data collection, preprocessing, and storage
    • 
                            
  • Feel that cloud IoT platforms are too grandiose
    • 
                            
  • Want to quickly launch an IoT platform combined with field devices like BraveJIG
    • 
                        

                    

                    

                        
Cases That Might Not Be a Fit Immediately

                        
    
                            
  • Want to rely on a large-scale managed cloud platform from day one
    • 
                            
  • Want to use a completely ready-made SaaS provided by a vendor
    • 
                            
  • Prefer introducing a finished business app rather than a custom design
    • 
                        

                    

                

            

        


        
        

            

                
Choose your deployment scale based on needs and budget

                
Kraken is designed not as a massive initial investment, but as a foundation that can start small and grow as needed.

                

                    
                    

                        
                        
Starter

                        
Minimal Setup

                        
Start with a single Raspberry Pi / Mini PC.

                        
Best forPoC, validation, and single-site deployments

                    

                    

                        
                        
Standard

                        
Standard Setup

                        
Stable operation on-premises or on VMs.

                        
Best forContinuous use involving multiple inputs, DB storage, and notification integration

                    

                    

                        
                        
Scalable

                        
Extended Setup

                        
Scale Collector/Broker using containers.

                        
Best forMultiple sites, diverse data flows, and operations eyeing future growth

                    

                

                
Whatever the scale, you grow with the same Collector / Broker setup.

            

        


        
        

            

                
Because it's OSS, rely on pros only where you need to

                
Kraken is free to use as open source. In real deployments, though, site-specific technical decisions matter: requirements, connecting existing equipment, adding Collectors, implementing Brokers, storage design, notification design, monitoring, and troubleshooting.

                

                    

                        Free · OSS
                        
What you can do on your own

                        
    
                            
  • Use Collector / Broker (MIT License)
    • 
                            
  • Standard inputs such as HTTP, MQTT, and Serial
    • 
                            
  • InfluxDB, Redis, MongoDB, WebSocket, and Slack integrations
    • 
                            
  • Implement and run your own Collectors / Brokers
    • 
                        

                    

                    

                        Paid · BathTimeFish
                        
What you can ask the developers for

                        
    
                            
  • Implementation consulting and PoC launch support
    • 
                            
  • Custom Collector development and custom Broker implementation
    • 
                            
  • BraveJIG CLI provision and BraveJIG integration support
    • 
                            
  • DB / notification / external system design
    • 
                            
  • On-premises configuration, containerization and scaling design
    • 
                            
  • Maintenance and troubleshooting
    • 
                        

                        Consult BathTimeFish
                    

                

                
As the developer of Kraken, BathTimeFish offers implementation consulting, custom development, and maintenance support. Keep the freedom of OSS and get help only where you need it.

            

        


        
        

            

                
FAQ

                

                    

                        
                        
Yes. Kraken is published as OSS and can be used for free.

                    

                    

                        
                        
It supports HTTP Webhooks, MQTT, WebSocket, iBeacon, serial communication, text file monitoring, Camera, Email, BraveJIG, and TCP Server.

                    

                    

                        
                        
Yes. Kraken is designed to allow starting IoT small on low-resource computers like Raspberry Pi.

                    

                    

                        
                        
Yes. Kraken is structured to be utilized in both cloud and on-premises environments.

                    

                    

                        
                        
Yes. The Broker can handle data processing, storage, and notifications. Integrations with InfluxDB, Redis, MongoDB, WebSocket, and Slack are possible.

                    

                    

                        
                        
Yes. By adding custom Collectors or Brokers, extensions tailored to your business requirements are possible.

                    

                    

                        
                        
Yes. Kraken Collector supports BraveJIG integration, and you can ingest sensor data into Kraken via the BraveJIG CLI (paid) provided by BathTimeFish. This allows you to build a complete workflow including preprocessing, DB storage, alerts, and external integration.

                    

                    

                        
                        
Yes. BathTimeFish provides implementation consulting, custom development, and operational support, in addition to providing the BraveJIG CLI and BraveJIG integration support.

                    

                

            

        


        
        

            

                
Try it first as OSS.
Consult the developers if needed.

                
Kraken is a highly flexible open-source platform created for sites wanting to start IoT small. You can try it immediately from GitHub. If you need implementation or scaling for real projects, BathTimeFish is here to support you.

                

                    
What you'll learn from consulting

                    
    
                        
  • Clarification of possible configurations with Kraken
    • 
                        
  • Feasibility and steps for BraveJIG integration (hardware sales available too)
    • 
                        
  • Minimal setup for a PoC
    • 
                        
  • Scope of necessary customizations
    • 
                        
  • Rough implementation roadmap
    • 
                    

                

                

                    View Kraken on GitHub
                    Consult regarding Implementation