Skip to main content

Introduction

Welcome to Rumour - a modern API platform designed to make API development, testing, and workflow management easier, faster, and more reliable.

Most traditional API tools only send requests and show responses. Rumour is different. It works like an intelligent execution system that understands how your APIs are connected and automatically manages the complex parts of the workflow for you.

Whether you are testing a small backend project, building microservices, or managing enterprise-scale systems, Rumour helps reduce repetitive work, avoid manual errors, and simplify API operations.

For example, imagine you are building an e-commerce application.

Normally, testing a workflow like this requires multiple manual steps:

  1. Login user
  2. Copy authentication token
  3. Create cart
  4. Extract cart ID
  5. Add products
  6. Place order
  7. Track payment session

With traditional tools, developers often copy IDs and tokens manually between requests. If one request fails or a token expires, the whole workflow breaks.

Rumour automatically handles these dependencies for you.

It can:

  • Detect tokens and IDs from responses
  • Pass data between requests automatically
  • Re-run failed authentication flows
  • Repair broken execution chains
  • Execute independent requests in parallel for better performance

This allows developers to focus more on building products instead of managing request chains manually.

The Rumour Platform

Rumour is more than just an HTTP client or testing utility.

It is a complete API platform built for:

  • Developers
  • QA teams
  • DevOps engineers
  • Security teams
  • Enterprise infrastructure environments

While Rumour provides a powerful Command Line Interface (CLI) for automation and CI/CD pipelines, the platform is designed to work across both technical and operational workflows.

The goal is simple:

Reduce complexity in API management while improving speed, reliability, and automation.

Core Capabilities

Intelligent Discovery​

Rumour automatically discovers useful data from API responses in real time.

For example:

A login API returns:

{
  "token": "eyJhbGc...",
  "user_id": 245,
  "session_id": "sess_8842"
}

Instead of manually copying these values into future requests, Rumour detects them automatically and makes them available throughout the workflow.

This is especially useful when working with:

  • Authentication systems
  • Session-based APIs
  • Payment systems
  • OAuth flows
  • Microservices
  • Temporary resource IDs

It removes the need for constant manual environment variable management.

Self-Healing Infrastructure​

One of Rumour’s most advanced features is its self-healing execution system.

In traditional API tools:

  • An expired token breaks the workflow
  • Missing resources stop execution
  • Dependency failures require manual debugging

Rumour can detect these problems during execution and attempt to recover automatically.

Example:

If an API request fails with:

401 Unauthorized

Rumour can:

  1. Detect token expiration
  2. Trigger the authentication node again
  3. Generate a fresh token
  4. Retry the failed request automatically

This creates a much smoother development and testing experience, especially for long-running workflows.

High-Concurrency Engine​

Rumour is built with performance and intelligent execution in mind.

Traditional API collections usually run requests one-by-one, even when requests are independent.

Rumour analyzes dependencies between nodes and determines which requests can safely run in parallel.

Example:

If your workflow includes:

  • Fetch users
  • Fetch products
  • Fetch analytics
  • Fetch notifications

and none depend on each other, Rumour can execute all of them simultaneously.

This significantly improves:

  • Execution speed
  • CI/CD performance
  • Load testing workflows
  • Large enterprise automation pipelines

The result is faster feedback and more efficient testing.

Enterprise-Grade Security​

Modern API workflows often contain sensitive information such as:

  • API keys
  • Access tokens
  • Database credentials
  • Client secrets
  • Internal endpoints

Rumour includes a secure Encrypted Vault system for storing sensitive data safely.

Secrets are protected using AES-256-GCM encryption, an industry-standard encryption method widely used in secure systems.

This helps teams:

  • Avoid exposing secrets in plain text
  • Share environments securely
  • Protect production credentials
  • Maintain safer CI/CD pipelines

Automated Documentation​

Keeping API documentation updated is one of the most frustrating parts of backend development.

Rumour helps automate this process.

The platform can generate:

  • Mermaid diagrams
  • Request flow maps
  • Technical documentation
  • Dependency visualizations

directly from your workflow definitions and API structures.

Example:

If your workflow contains:

Login → Create Cart → Add Product → Checkout

Rumour can automatically generate a visual workflow diagram for your documentation.

This helps teams:

  • Understand systems faster
  • Reduce onboarding time
  • Maintain updated technical docs
  • Improve collaboration between developers and QA teams

Ownership and Proprietary Status

Rumour is a proprietary, closed-source platform owned and operated by Swahira.

The platform is not open source, and access to the internal source code, build systems, and infrastructure is controlled under Swahira’s licensing and security policies.

Rumour is being engineered with a strong focus on:

  • Reliability
  • Security
  • Performance
  • Developer experience
  • Enterprise scalability

Leadership

Rumour is designed and led by Manisha Kumari, Founder and CEO of Swahira.

The project represents a combination of:

  • System architecture
  • Workflow automation
  • Developer tooling
  • Performance engineering
  • API infrastructure design

The platform has been developed with the goal of solving real-world problems developers face daily while working with complex APIs and distributed systems.

Technical Foundations​

To use Rumour effectively, it is important to understand its core building blocks and how they orchestrate complex API behaviors.

Nodes (The Request Unit)​

A Node is the smallest execution unit in Rumour. Every API request is represented as a Node.

A Node can:

  • Send authenticated requests.
  • Consume data (dependencies) from other nodes.
  • Produce outputs (extraction) for future nodes.
  • Define local variables and assertions.

Workflows (The Execution Plan)​

Workflows are collections of connected Nodes defined in declarative .toml files. Rumour analyzes these files to build an optimized Dependency Graph.

Correct Dependency Example (get_user_profile.toml):

[request]
method = "GET"
url = "{{base_url}}/profile"

[dependencies]
# This node depends on the 'login' node to provide the 'auth_token'
login = "auth_token"

This configuration tells Rumour that it must run the login node before get_user_profile and pass the extracted auth_token into the current request's context.

Execution Configuration ([config])​

Rumour allows you to define execution behavior at both the directory and modular levels using a [config] section. This is supported in:

  • collection.toml: For settings that apply to an entire directory and its subdirectories.
  • *.config.toml: For modular, reusable configurations that can be shared across different workflows.

Available Configuration Tags:

  • parallel (Boolean): Enable or disable high-concurrency execution.
  • heal (Boolean): Enable the self-healing engine to recover from common failures (e.g., token expiration).
  • hard_heal (Boolean): Force a full re-authentication and state reset on persistent failures.
  • resume (Boolean): Pick up execution from the last failed node instead of starting over.
  • auto_cleanup (Boolean): Automatically delete temporary resources created during the workflow.

Node-Level Configuration​

While directory-wide settings use the [config] block, individual request files (Nodes) can define their own orchestration behavior using root-level tags. This allows for granular control over specific parts of a workflow.

Supported Node Tags:

  • retries (Integer): Number of self-healing attempts specifically for this node (Overrides global settings).
  • ordered (Boolean): If set to true, this node will be executed sequentially even in parallel mode.
  • skip (Boolean): Exclude this specific request from the execution path.

Example create_user.toml:

[request]
method = "POST"
url = "{{base_url}}/users"

# Node-level orchestration
retries = 5
ordered = true

Example collection.toml:

[config]
parallel = true
heal = true
resume = false

[headers]
X-Source = "Rumour-Enterprise"

Example performance.config.toml (Modular Config):

# A reusable configuration for load-testing or high-speed runs
[config]
parallel = true
concurrency = 50
heal = false

Test Suites (*.suite.toml)​

While Workflows automatically calculate dependencies across a directory, Suites allow you to curate specific execution paths. Suites are defined in *.suite.toml files and are ideal for smoke tests, regression sets, or specific user journeys.

A Suite allows you to:

  • Explicitly Group Requests: Define exactly which .toml nodes should run.
  • Control Ordering: Override automatic dependency calculation with a fixed, ordered sequence.
  • Suite-Level Variables: Provide variables that apply specifically to the requests in the suite.

Example smoke_test.suite.toml:

[suite]
name = "Production Smoke Test"
description = "Verifies core API health in production"
requests = [
  "auth/login.toml",
  "users/get_profile.toml",
  "health/ping.toml"
]
ordered = true

[variables]
test_mode = "smoke"

Environments (.env.toml)​

Rumour supports a robust environment management system via .env.toml files. Unlike traditional tools that store environments in a hidden database, Rumour treats them as first-class, version-controlled files.

An environment file can contain root-level keys and a specialized [variables] table:

# Example workspace.env.toml
base_url = "https://api.production.com"

[variables]
timeout = "30s"
retry_count = 3

When running a workflow, you specify the environment file (e.g., rumour run . --env staging.env.toml), and Rumour merges these values into the global execution context.

Why Rumour Exists

Modern APIs are becoming more complex every year. Applications now depend on microservices, authentication chains, and event-driven architectures. Traditional request-based API tools struggle to manage this complexity efficiently.

Rumour was created to solve these challenges by introducing:

  • Dependency Awareness: Understanding how data flows between systems.
  • Intelligent Automation: Handling authentication and state transitions automatically.
  • Developer Velocity: Focusing on building products, not managing request chains.

Leadership & Vision

Rumour was envisioned and created by Manisha Kumari, Founder & CEO of Swahira, to address the core inefficiencies of modern API testing and deployment cycles. Under her leadership, Swahira continues to develop innovative tooling that empowers backend engineers, site reliability teams, and security professionals to automate their workflows securely and reliably.

Try the Examples Instantly!

Want to skip the manual setup and start experimenting right away? Clone the official Rumour Testing Examples GitHub Repository containing all configuration templates, variables, authentication chains, and test suites showcased in the documentation!

git clone https://github.com/swahira/rumour_testing.git

Ready to get started? Continue with the Installation Guide.