Welcome! We have cooked up a few tutorials to help you get started on ByteNite.

ByteNite’s serverless container platform is built for high-performance teams and developers who need fast startup times, flexible compute, and a simpler path to getting things done—without the headaches of traditional cloud infrastructure.

But we don’t just host containers. We’ve designed a distributed execution fabric that eliminates cold starts, streamlines app architecture, and gives you full control over your container environments—without the overhead of managing infrastructure.

With ByteNite, you can focus on building your app and leave the heavy lifting to us:

• Write your core application and fan-out/fan-in logic in the programming language you know best.

• Package your dependencies using any public or private Docker container image.

• Define environments and hardware specs with a lightweight manifest file.

• Submit jobs that are automatically partitioned, scheduled, and executed across pre-warmed cloud runners—powered by our proprietary distributed execution fabric.

Ready to dive in? This documentation site covers everything you need, from getting started to scaling complex workloads.

Documentation overview

Our docs are here to guide you—from first steps to advanced workloads. Whether you’re exploring tutorials, learning about core system components, or diving into API references, you’ll find everything you need to build, manage, and scale apps on ByteNite.

1. Understanding the workflow

We’ve broken down distributed computing into a few key components to make building and managing apps simpler. To get started, check out our guide, where you’ll dive into the typical processing job's lifecycle and get an overview of each stage, learning example use cases across different data types.

Here’s a quick rundown of a typical setup:

• Partitioner – Pre-processes and splits your input data into manageable chunks.

• App – Runs the core logic and handles the heavy lifting of your workload.

• Assembler – Merges or cleans up the output once processing is complete.

2. Checking out tutorials

If you’re new to ByteNite, a great place to start is with our tutorials. They walk you through real examples, so you can get hands-on experience and see how everything fits together.

While it’s tempting to jump straight into building your own applications, we recommend browsing the full system guides first. They’ll help you understand the bigger picture and the components that power ByteNite.

3. Taking the next steps: build and launch your apps

Once you’re comfortable with how ByteNite works, the next step is diving into the guides that help you build, launch, and manage your apps effectively.

You’ll learn how to structure your workloads using ByteNite’s modular components, connect your data sources, and run distributed jobs. After that, you’ll explore the API that ties everything together—allowing you to automate job launches, manage secrets, access logs, and more.

Head over to the guides below to get the full rundown:

Product & services

ByteNite’s serverless computing platform offers APIs and interfaces designed to make app development and workload management smoother at every stage.

As a ByteNite user, you have access to all our services, fully documented right here.

Below, you’ll find our user-facing components, grouped into:

• UIs – For interacting with your apps, monitoring jobs, and managing configurations.

• APIs – For programmatic access to launch jobs, manage data, and integrate with your workflows.

UIs

APIs

At ByteNite, a typical job follows this lifecycle:

1. Launch Phase: The customer initiates a job via the ByteNite API, specifying the data source and configuration details. The system pulls data from various cloud storage services (AWS S3, GCP, Azure, etc.).

2. Create Phase: This encompasses three stages:

ByteNite's building blocks are designed to help you structure your distributed workloads into modular, reusable components. These components—Partitioners, Apps, and Assemblers—let you focus on your core logic without worrying about the complexities of distributed execution, fault tolerance, retries, or logging. We've got that covered.

At a high level, ByteNite breaks down a distributed job's lifecycle into three phases:

1. Partitioning Engine: Handles input downloading, pre-processing, and task creation.

2. App: Executes the core logic for each individual task.

3. Assembling Engine: Collects and merges the results from individual tasks.

Each component is fully customizable and versionable, enabling you to build flexible pipelines that fit your specific needs.

Explore the following guides to learn how to develop your own ByteNite Apps, Partitioning Engines, and Assembling Engines to create distributed workflows tailored to your needs.

Get all you need to begin running workloads on ByteNite and doing some Byte-magic!

👤 Create an account

1. Get an access code Currently, our platform is in beta and you'll need an access code to create an account. If you have one, use it when required during the sign-up process. Otherwise, you can Request an Access Code.

2. Sign up on Computing Platform To create an account on ByteNite, follow this link and fill out the form with your contact info and your access code: .

💳 Add a payment method

Having an account is sufficient for creating apps and start playing around with ByteNite. However, once your credits are over you’ll need an active billing account to keep launching jobs. Follow the steps below to add a payment method to your account and activate it.

1. Access your Billing page After registering and logging in, go to or navigate to the Billing page on the sidebar.

2. Add a payment method Locate the Payment Info card an navigate to the Customer Portal. Follow the steps to add a payment method to your account.

NOTE: Your payment information will be stored for manual top-ups as well as automatic top-ups triggered by the end of the current billing cycle. Make sure you have enough funds to cover your previous billing cycle's costs to avoid service interruptions.

🪙 Redeem ByteChips

If you have a coupon, you can redeem it on your billing page to add ByteChips to your balance.

1. Access your Billing page: After registering and logging in, go to or navigate to the Billing page on the sidebar.

• Redeem a coupon: Go to the Account Balance card and click on "Redeem". Enter your coupon code in the corresponding field and complete the process. Ensure the amount has been added to your balance; refresh the page if needed.

We'd love to get you started with free credits to test our platform. If you haven't received free ByteChips upon signing up, and we'll grant you some.

🔐 Get an API key

For programmatic access to our API, you'll need an API key linked to your account. You can have multiple keys, each meant for a specific integration. Follow these steps to get a key:

1. Access your profile After registering and logging in, go to or click on your profile avatar located in the top right corner of the webpage.

2. Create a new API key On your profile page, locate and click the 'New API Key' button or link.

3. Configure your API key settings Provide a descriptive name for your API key, choose its validity duration, and enter the confirmation code sent to your email. After filling out the necessary details, click the 'Generate API Key' button.

1. Managing your API keys If your key is no longer needed or is compromised, return to the API section in your profile. Find the key and click 'Revoke' to invalidate it.

🔑 Get an access token

An access token is required to authenticate all requests to the ByteNite API, except for OTP and access token requests.

To request an access token, send a request to the endpoint using your API key.

Access tokens have a default duration of 3600 seconds (i.e., 1 hour). Once expired, you must request a new one.

🛠️ Set up development tools

Here are some recommended tools to get started with ByteNite's.

1. Download & set up ByteNite Dev CLI:

1. Set up ByteNite API:

About

• Base URL: https://api.bytenite.com/v1/dev

• Version: v1

• Swagger Docs:

• Specification:

With ByteNite, you can save your output files to a temporary storage location on Google Cloud at no additional cost.

This temporary bucket is intended for short-term use and is automatically managed to ensure file security and accessibility. ByteNite generates a temporary authenticated direct access URL for each output file or folder, simplifying access to your results.

Files remain available for 48 hours after being saved in the temporary storage, after which they are permanently deleted. This setup is perfect for workflows requiring short-term file storage without ongoing management.

The temporary storage bucket is exclusively a data destination, designed for saving output files from your jobs. It cannot be used as a data origin for sourcing input files.

About

• Base URL: https://api.bytenite.com/v1/wallet

• Version: v1

• Swagger Docs:

• Specification:

Learn how to create API keys:

• 🔐 Get an API key

The goal of this tutorial is to build a simple ByteNite app that outputs the string "Hello, World!" to a file. Use this tutorial if you're new to ByteNite and want to have a quick sense of the workflow.

Uploading input files directly from your computer makes it convenient to process local content for tests.

We require a 4-step process for uploading local files, which involves configuring a data source, retrieving a temporary upload URL, uploading the file, and notifying the server upon completion.

Introduction

You can fetch files directly from a public URL pointing to the raw resource, which is especially useful for utilizing temporary access URLs generated by cloud storage providers not integrated with ByteNite.

Keep in mind that an HTTP source serves solely as a data origin, meaning it cannot be used as a data destination. This ensures that data fetched via HTTP can be read and processed, but not directly modified or uploaded back through this method.

Release Notes – October 6, 2025

✨ New Features

• Added support for secret type “other”, expanding secret management capabilities.

In order to authorize your API calls, you will need an access token. For security, the only way to programmatically obtain an access token is by exchanging it for an API key. Learn how to:

About

• Base URL: https://api.bytenite.com/v1/auth

• Version: v1

The Dev CLI is a tool for developers to create and manage apps on ByteNite.

Download & Install

Linux

Follow these steps to install the ByteNite CLI on Ubuntu, Debian, or similar distributions.

1. Add the ByteNite Repository

1. Update Package Lists

1. Install the ByteNite CLI

Troubleshooting

If you encounter any issues during installation:

• Make sure your system is up-to-date:

• Verify the repository was correctly added:

• Check if the package is available:

Mac

Installation

1. Add the Bytenite Tap

1. Install the CLI

Updating

1. Update Homebrew's formula list (including your tap)

1. Upgrade the bytenite package specifically

Windows

Download and run the latest Windows release from .

Verify Installation

Check that the installation was successful by using:

Authenticate

To authenticate, run:

This will open an oAuth2 authentication page in your browser. The login is automatic if you're already logged in on ByteNite.

After successful authentication, credentials will be stored in the application support or configuration directory:

• Linux: /$HOME/.config/bytenite-cli/auth-prod.json

• Mac: /Users/[user]/Library/Application Support/bytenite-cli/auth-prod.json

Commands & Usage

Run the help command to get started with the ByteNite Dev CLI:

Authentication

• Authenticate with OAuth2: bytenite auth

Version

• Get Dev CLI Version: bytenite version

App Commands

• App Command Info: bytenite app --help

• Initialize New App: bytenite app new [app_name]

• Push/Upload App: bytenite app push [app_folder]

Template Commands

• Template Command Info: bytenite template --help

• Initialize New Template: bytenite template new [template_id]

• Push/Upload Template: bytenite template push [template_filepath]

Engine Commands

• Engine Command Help: bytenite engine --help

• Initialize New Engine: bytenite engine new [engine_name]

• Push/Upload Engine: bytenite engine push [engine_folder]

About

• Base URL: https://api.bytenite.com/v1/customer

• Version: v1

• Swagger Docs:

• Specification:

A Job Template (or simply Template) combines Building Blocks into one configuration file for your jobs. It:

• Provides instructions to the services that execute your job.

• Ensures your app and data engines are connected correctly.

By default, ByteNite generates a job template when you start building a new app. This allows you to focus on developing your app without needing to configure the other components upfront.

However, since your app may expect specific data types or formats, you can create and customize a job template to link your app to the appropriate partitioning and assembling engines.

A.

Alongside your entry point script, ByteNite injects your container with environment variables. These variables provide paths to your app’s input and output folders, cache directories for data sharing and persistence, as well as job parameters and secrets for secure configuration.

Configuring your app’s data flow using these variables ensures your job runs smoothly and interacts properly with ByteNite’s components.

This page explains how ByteNite’s environment works for your containers, focusing on two key areas:

• Secret management: How secrets are made available to your app (data source/destination linking, environment variable injection, and API-based access).

• Cache directories: How ByteNite provides built-in directories for storing and accessing data at runtime.

You’ll learn how to structure your platformConfig object within your manifest.json, what environment variables are available inside your container, and how these features impact your build and deployment process.

🔑 Secret Management Approaches

ByteNite supports multiple ways to provide secrets to your app, depending on your workflow:

🔗 Job Data Source/Destination Linking

How it works:

• You link secrets to data sources/destinations (e.g., S3, GCS) during job submission (via UI or ).

• The platformConfig's secrets property is typically not required for this approach.

• The secret is referenced in the job’s , not in the platform config.

Example (platformConfig):

No need to reference secrets in platformConfig for data movement.

Build/Deployment:

• Build your container as usual.

• ByteNite manages authentication and data transfer using the linked secrets, so your code never handles credentials.

When to use:

• When your job only needs to read or write data (like to S3 or GCS) and does not need to make custom API calls.

• This method is simple and secure, as your code never sees the credentials and ByteNite manages all authentication and data transfer automatically.

✍️ Environment Variable Injection

How it works:

• Use this when your app code needs to interact with external services (APIs, SDKs, databases) that require credentials at runtime.

• ByteNite injects your secrets as environment variables so your code can securely access them.

Typical use cases:

• Authenticating to external APIs (e.g., AWS, GCP, OpenRouter, Twilio, Hugging Face, etc.)

• Connecting to managed databases or message queues

• Using SDKs or CLI tools that expect credentials in environment variables

Example (platformConfig):

Once your manifest.json is configured, you can access the injected secrets in your code like shown below:

Example (Python):

Build/Deployment:

• Build your container as usual.

• Ensure your code reads secrets from environment variables.

• Ensure the correct secret IDs are referenced in platformConfig.

When to use:

• When your code needs to make authenticated requests to external services, use cloud SDKs, or perform any operation that requires direct access to credentials at runtime.

📂 ByteNite Cache Directory Environment Variables

In addition to secrets, ByteNite automatically injects cache directory environment variables (USER_CACHE_DIR and SHARED_CACHE_DIR) into your container at runtime. These directories are essential for storing user-specific data and accessing shared resources within your app environment.

For a full explanation of how these variables work, including usage examples and best practices, see the section.

Summary:

• Secrets: Use data source/destination linking for simple data movement, or environment variable injection for direct credential access in your code.

• Cache Directories: Use USER_CACHE_DIR for user-specific, persistent storage; use SHARED_CACHE_DIR for global, read-only resources.

• All these environment variables are automatically injected by ByteNite and available inside your container at runtime.

By understanding these environment variables and secret management approaches, you can configure your containers securely and efficiently, and make the most of the ByteNite platform.

Introduction

Amazon S3 (Simple Storage Service) is a scalable, high-speed, web-based cloud storage service designed for online backup and archiving of data and applications. It offers secure, durable, and highly-scalable object storage, making it ideal for a wide range of use cases, from data lakes and mobile applications to backup and restore operations.

Follow the guide below to set up an account and get IAM credentials on AWS S3:

Introduction

The ByteNite Computing Platform GUI is a web interface that enables users to manage and monitor distributed computing jobs on ByteNite, allowing users to launch, track, and control their workloads.

Job Management

Create New Jobs

In order to create a new job, from the Jobs page, click the "New Job" button at the top. Here, you'll have two options:

• Start from Scratch - you'll manually configure all parameters, including:

  • Job Details - job name and description

  • App Details - deployed app references for your partitioner, app, and assembler (you may specify versioning to test specific versions of your app, partitioner and assembler, by default the most recent version of each will be used)

• Use a Template - Alternatively, you can pick an existing template from your Templates table and click on it to create a new job. This will give you the option to create a job to either run later or immediately, using the preconfigured data source and destination, parameters, and configs you defined in your selected template.

Launch Jobs

You can launch a new job immediately after configuration in Start from Scratch by clicking Create & Run Job, as shown in the demo video in the section above. Alternatively, clicking Create Job allows you to save the job as a draft. You can later execute it using job actions from the Jobs page or the job overview by selecting Run Job.

You can additionally launch a job from a pre-saved template using Use a Template. Simply select the row of which template you would like to use and confirm that it is configured correctly. For more information on how to properly define your jobs, see the parameters in the Start from Scratch section above.

Delete Jobs

Remove jobs that are no longer needed, with confirmation prompts to prevent accidental deletion. This can be conducted through the Jobs page or through the red button on the top right of the specific job's Overview page.

Job Logging & Monitoring

View real-time statuses such as Running, Complete, and Failed, along with progress bars for each job on the Jobs page. More detailed, time-stamped task status tracking is available on the Job's Overview page.

Additionally, the Job Overview page includes a Logs section, which contains logs from the partitioner, app, and assembler processes. While the logs are presented comprehensively, they can be filtered for troubleshooting by categories: error, warning, info, debug, and unknown. These logs are also queryable and downloadable.

Task Management

Tasks are the individual units of work that make up a job. Each job may consist of multiple tasks, which can be executed in parallel or sequence, depending on the workload.

View Task Breakdown & Progress

Inspect the list of tasks associated with a job, breaking down their time-stamped state (Scheduled, Assigned, Received, Running, Completed) and price. Deeper insights are available at the individual task level, including the container stats, network stats, and device info.

Task Logs

Access detailed logs for each task by clicking into that specific Task ID to diagnose issues at a granular level.

Templates Management

The Templates page allows users to observe and reuse submitted job templates for common or recurring workloads. Templates help ensure consistency, reduce setup time, and minimize errors when launching similar jobs. For info on using templates for job setup, view Use a Template in the section above.

If you want to delete a template, simply select the ellipses at the end of the row of the desired template and click Delete.

Security

The Security section houses both the pages for API Key and Secret Management:

API Keys

The API Keys page allows users to securely generate and manage their personal API keys. These keys are essential credentials required to access the platform’s APIs, enabling programmatic interaction with ByteNite’s distributed computing services.

On this page, users can:

• Create New API Keys: Generate unique API keys for use in scripts, applications, or integrations that need to interact with the ByteNite platform outside of the web interface.

• View and Copy Existing Keys: Easily view your active API keys and copy them for use in your development environment or automation tools.

• Revoke Keys: Revoke keys that are no longer needed.

Secrets

The Secrets page lets you manage credentials used by your apps and engines across your jobs. ByteNite currently supports secret types from AWS, GCP, and Storj. All that's needed from you prior to setting up your secret is your Access Key and your Secret Key from that respective platform.

Each secret is assigned a unique Secret ID, defined by you, which you can reference in your environment variable configuration to inject credentials at runtime—eliminating the need to hardcode sensitive values.

For step-by-step instructions on using Secret IDs in environment variables, see: .

Billing

The Billing page is where users manage their transactions. It includes several key sections:

Usage Overview

This section displays ByteChip usage over a selected month. Users can adjust the view to focus on a specific month or template.

Wallet Balance

Here, users can add ByteChips to their account via Top Up or Coupon Redemption. This section also allows users to view and copy their account ID, check both total and available balances, and see the amount due. Additionally, it includes a Customer Portal button for accessing the ByteNite Stripe integration.

Wallet Transactions

This section lists all your transactions. It provides detailed information such as transaction type (Top Up, Coupon, Payment), description, costs in both ByteChips and USD, and the remaining balance.

Contact Us

The Contact Us page provides a simple way for users to reach the ByteNite team with questions, issues, or feedback. To submit a query, just fill out the following fields:

• Email: Enter your email address so we can get back to you.

• Summary: Provide a brief summary of your request or concern.

• Description: Use this field to describe your issue or feedback in detail.

Once submitted, our team will review your message and respond as soon as possible.

Documentation

The Documentation page will redirect you to page, where you can find detailed guides, feature overviews, and best practices for using the ByteNite Computing Platform.

Developer CLI

The Developer CLI page will take you directly to the page, explaining setup instructions, usage examples, and advanced command references.

Introduction

Google Cloud Storage offers a highly scalable, secure, and durable object storage service designed to handle unstructured data across various use cases. With a unified API and integration across Google Cloud services, it supports efficient data retrieval and storage management. Its tiered storage options—ranging from high-performance to cost-effective archival—make it a versatile solution. Beyond its native ecosystem, Google Cloud Storage is widely adopted for hybrid and multi-cloud strategies due to its interoperability and global availability.

Follow the guide below to set up an account and get HMAC credentials on GCP:

Introduction

Storj is a decentralized cloud storage platform that offers secure, private, and cost-effective data storage. By distributing data across a global network of nodes, Storj ensures highly-available and resilient data access, while securing cost savings to up to 90% than traditional cloud providers.

Follow the guide below to set up an account and get S3-compatible access keys on Storj:

If your app needs data to function (which most do), it’s crucial to configure your data connections properly. This guide walks you through securely storing credentials, testing connections, and setting up your data sources.

ByteNite jobs can read and write from popular storage services, including Amazon S3 and Google Cloud Storage buckets.

How it works

Once your Apps, Partitioning Engines, and Assembling Engines are ready, and you've linked them together using Job Templates, you're prepared to launch test and production jobs.

ByteNite utilizes an API to handle job requests — the Customer API— simplifying and standardizing the interaction with our server.

To begin using the API and familiarizing yourself with its endpoint, we recommend setting up a Postman collection. You can find more details at Create a Postman collection from ByteNite's OAS.

Below are the steps to configure and send a new job request, broken down and explained. You may refer to the official Jobs reference for a complete parameter list, response codes, and default code examples.