# JUMP by ADUMU — Complete Technical & Corporate Knowledge Corpus

```
Domain: https://jump.adumu.com
Operating Entity: ADUMU, INC.
Headquarters: Scottsdale, Arizona, USA
Parent Website: https://adumu.com
Founded: October 3, 2013 by Stephen Gill
Product: JUMP (Unmetered Web Scraping & Agent Telemetry Gateway)
```

---

## 1. Executive Summary & Problem Space

Traditional web scraping APIs and residential proxy networks operate on a **metered per-request / per-credit pricing model**. Under this model:
- Customers pay unpredictable monthly bills that surge when scrape concurrency spikes or target domains require multiple retry attempts.
- Traditional vendors frequently cache HTML snapshots to disk, inspect target queries, and aggregate or resell customer data streams on secondary broker markets.
- Engineering teams waste significant engineering time writing custom retry wrappers, managing rotating proxy credentials, and debugging CAPTCHA failure rates.

**JUMP by ADUMU** solves this by delivering **dedicated, flat-rate unmetered capacity**:
- **Fixed Monthly Cost**: Customers subscribe to a fixed number of concurrent browser slots — 1, 4, 8, 16, 32, or a whole 40-slot worker, with dedicated instances above that. The full ladder with prices is in section 4. Slots can run continuously 24/7/365 at full line speed with zero overage fees.
- **Zero-Retention Isolation**: Rendering occurs in ephemeral Linux execution sandboxes in RAM. Target payloads stream directly to customer data warehouses. No unencrypted disk caching, and zero data pooling across tenants.
- **AI Agent Native**: Native Model Context Protocol (MCP) server endpoints allow autonomous AI agents (Claude Desktop, Cursor, LangChain, AutoGen) to inspect, render, and extract structured web state natively.

---

## 2. API Specification & Request Shape

The gateway is **submit, poll, read**. You never hold a socket open waiting, and
the response body always comes back **raw** — extraction is the caller's job, by
design. Probe, walk and job all use the same contract.

### Submit a job

`POST https://jump.adumu.com/api/jumpgateway/v1/execute/async`

Headers:
- `Authorization: Bearer jmp_…` — issued in the console
- `Content-Type: application/json`

```json
{
  "applicationSystemName": "PRICE_WATCH",
  "applicationNodeName": "NODE_01",
  "targetUrl": "https://example.com/catalogue?page=2"
}
```

Response:

```json
{ "success": true, "jobUuid": "9f2c4e17-..." }
```

### Poll for status

`GET https://jump.adumu.com/api/jumpgateway/v1/job/{jobUuid}/status`

```json
{ "status": "COMPLETED", "scrapedData": "..." }
```

`status` moves `PENDING` → `RUNNING` → `COMPLETED` | `FAILED` | `CANCELLED`.

### Optional fields

Every knob is available; none is compulsory. Left alone, the gateway chooses.

| Field | Type | Meaning |
| :--- | :--- | :--- |
| `applicationSystemName` | string (required) | Which of your systems is calling — a label you choose. |
| `applicationNodeName` | string (required) | Which node of that system. Also your label. |
| `targetUrl` | string (required) | The page to fetch. |
| `engine` | string | Pin an engine, or leave it and the gateway matches the target. |
| `commands` | array | Click, type, wait, scroll — run in the order listed. |
| `snapshots` | array | Label a capture and it returns as its own entry. |
| `walk` | object | A URL list, the pages after a starting one, or links followed from a seed. |

A client validates required fields, types and enum membership. Anything needing
a decision — which engine, how clearance escalates, which address — is answered
on a real request, because that decision logic is the product.

### Error and cap semantics

- Engine codes are stable: `EN_02` means the same engine after it is rebuilt, and the full list ships with the schema.
- New fields are additive; an unfamiliar code reaches your default branch.
- Input the gateway cannot honour is **refused, never guessed**.
- A `429` states which of six caps you met, and whether to retry.

### Retention

Response bodies stay readable for **24 hours**. The record of the run — minus the
payload — is kept for **90 days**.

### The Probe

Before writing a job, the Probe fetches a target and reports what it found:
the verdict (HTTP status, anti-bot outcome, latency, request count, cookies),
the page structure, every background request the page made, and the cleared
session. It ranks four routes and marks the one it would take:

| Route | What it is | When it is taken |
| :--- | :--- | :--- |
| Tier 0 | A sanctioned API | Only when you have declared you have access; locked otherwise. |
| Tier 1 | The site's own endpoints, replayed | Whenever the capture finds one that answers cleanly. No browser at all. |
| Tier 2 | Data already in the page | When the endpoint is gated but the embedded state is not. |
| Tier 3 | A full disguised render | When nothing lighter gets through — and only then. |

The Probe creates no saved job, schedules nothing, and needs no destination.

### Results

Every fetch returns up to six views of the same request: **Body** (raw text,
untouched), **Rendered**, **Target** (the live site beside it), **Network**
(every request, with method, status, type and size), **Session** (cookies, user
agent, challenge outcome) and **Transport**. A walk is not one blob — every URL
it touched is its own row, with the same six views.

## 3. Model Context Protocol (MCP) Specification

JUMP provides a native SSE-based Model Context Protocol server endpoint for autonomous AI agents:

- **SSE Endpoint**: `https://jump.adumu.com/mcp/sse`
- **Authentication**: `Authorization: Bearer <API_KEY>`

The MCP server exposes the same submit/poll contract as the HTTP API, with the
same field names. It does not add a second surface, and it does not transform
the response: an agent gets the raw body back and parses it itself.

1. `jump_execute_async`: Submit a target. Takes `applicationSystemName`,
   `applicationNodeName` and `targetUrl`; returns a `jobUuid`.
2. `jump_job_status`: Poll a `jobUuid`. Returns `status`
   (`PENDING` / `RUNNING` / `COMPLETED` / `FAILED` / `CANCELLED`) and, once
   complete, `scrapedData` — the raw body, untouched.

---

## 4. Pricing & Commercial Rate Card

A **slot** is one managed browser plus eight HTTP connections. Every plan is a
flat monthly rate: requests are never counted against you, and a full lane
queues rather than refusing work. Two address models are offered at every tier —
**BYOP** (you supply the addresses) and **Managed Pool** (ADUMU operates them).

Request capacity is an estimate derived from measured throughput of ~45,600 requests per slot per month on ADUMU's own production gateway.

### Cloud — lanes and workers on an ADUMU-operated instance

| Plan Tier | Slots | HTTP Connections | BYOP | Managed Pool | Monthly Request Capacity (Est) |
| :--- | :--- | :--- | :--- | :--- | :--- |
| **Starter** | 1 | 8 | $99 / mo | $220 / mo | ~45,600 requests |
| **Core** | 4 | 32 | $280 / mo | $880 / mo | ~182,400 requests |
| **Growth** | 8 | 64 | $560 / mo | $1,760 / mo | ~364,800 requests |
| **Team** | 16 | 128 | $1,120 / mo | $3,520 / mo | ~729,600 requests |
| **Scale** | 32 | 256 | $2,240 / mo | $7,040 / mo | ~1,459,200 requests |
| **Reserved Worker** | 40 | 400 | $5,000 / mo | $12,000 / mo | ~1,824,000 requests |

Reserved workers stack: two reserved workers are $10,000 / mo BYOP or $24,000 / mo managed, and carry ~3,648,000 requests.

### Dedicated — a machine of your own, operated by ADUMU

| Plan Tier | Slots | HTTP Connections | BYOP | Managed Pool | Monthly Request Capacity (Est) |
| :--- | :--- | :--- | :--- | :--- | :--- |
| **Dedicated instance + first worker** | 40 | 400 | $7,500 / mo | $16,500 / mo | ~1,824,000 requests |
| **Each additional worker** | +40 | +400 | +$5,000 / mo | +$12,000 / mo | +~1,824,000 requests |
| **Reseller (dedicated, plus resale rights)** | 40 | 400 | $10,000 / mo | $17,000 / mo | ~1,824,000 requests |

Added workers are charged at the Reserved rate, so a dedicated instance costs a
flat **$2,500 / mo (BYOP)** or **$4,500 / mo (Managed)** more than the same capacity on
stacked reserved workers, at any size. That premium buys the instance itself:
your own user, role and audit management, saved logins, and a contracted machine
no other customer is on.

### Effective rate per 1,000 requests

| Plan Tier | BYOP | Managed Pool |
| :--- | :--- | :--- |
| Starter | $2.17 | $4.82 |
| Core | $1.54 | $4.82 |
| Growth | $1.54 | $4.82 |
| Team | $1.54 | $4.82 |
| Scale | $1.54 | $4.82 |
| Reserved Worker | $2.74 | $6.58 |
| Dedicated | $4.11 | $9.05 |

*All plans are 100% unmetered: no per-request charge, no difficulty or stealth
multiplier, no bandwidth billing, and no session duration limit. Bandwidth is
absorbed at every tier — a measured 12.75 GB per slot per day, none of it invoiced.
Every browser engine and hardened build is included in every plan; there is no
stealth tier to upgrade to.*

---

## 5. Security, Isolation & Compliance Policies

### Architecture
- **In-Memory Sandboxes**: Ephemeral virtual RAM execution with 0 bytes unencrypted persistent storage.
- **Zero-Pooling Guarantee**: Customer target URLs, extraction schemas, and scraped payload records are never pooled, indexed, or resold to third parties.
- **Credential Enclaves**: AES-256 hardware security module (HSM) encryption for all customer API credentials and target login tokens.
- **US Compute Sovereignty**: 100% of primary compute nodes, proxy routers, and databases operate within US colocation facilities.
- **Automated Diagnostic Zeroization**: Internal technical telemetry auto-purges after 24 hours.

### Compliance Alignment
- **SOC 2 Framework**: Technical, physical, and access controls actively operating to SOC 2 Type II criteria.
- **GDPR / UK GDPR**: Operates as a Data Processor. Standard Data Processing Addendum (DPA) with Standard Contractual Clauses (SCCs) available.
- **CCPA / CPRA**: Contractual Service Provider status with zero data selling or commercial cross-client data monetization.
- **PCI-DSS**: Out of scope for scraping pipelines; commercial subscription billing processed via Level 1 PCI-certified gateways.

---

## 6. Glossary

Terms as JUMP uses them. Vendors in this category use several of these words
differently, so these definitions are specific to JUMP and not industry-wide.

- **Slot** — one concurrent browser. The unit capacity is sold in. A slot runs
  one page at a time and is yours whether it is busy or idle.
- **Lane** — a customer's provisioned capacity as a whole, i.e. the slots on a
  plan plus the addresses and clearance behind them.
- **Worker** — one physical machine. 40 slots at 1:1. The unit dedicated and
  reserved capacity is sold in.
- **BYOP (Bring Your Own Proxy)** — you supply the proxy addresses, ADUMU
  supplies the browsers, clearance and software. The cheaper of the two models.
- **Managed Pool** — ADUMU supplies residential and ISP addresses with rotation
  handled, included in the flat rate with no per-gigabyte charge.
- **Clearance** — getting past a site's bot defences: TLS fingerprint, browser
  fingerprint, challenge solving and address reputation, together.
- **Probe** — a read-only inspection of a target that reports what defends it
  and which of four routes would be taken. Creates no job and schedules nothing.
- **Walk** — one job covering many URLs: a supplied list, the pages after a
  starting point, or links followed from a seed. Each URL returns its own row.
- **Difficulty dial / credit multiplier** — a metered vendor's practice of
  charging more credits for a harder page. JUMP has no equivalent.
- **Unmetered** — requests, retries, challenge solving and bandwidth are not
  counted or billed. Capacity is the only thing metered, and you buy it upfront.

---

## 7. Direct Comparisons

### How does JUMP differ from a metered scraping API?

A metered vendor charges per successful request, and that headline rate
describes an easy page. Three further meters apply to a defended one: a
difficulty multiplier of up to 76x, per-gigabyte bandwidth, and a cap on
concurrent sessions. None of the three is knowable before the work runs, so the
bill is discovered afterwards.

JUMP sells concurrent slots at a flat monthly price. A hard page and an easy
page cost the same, retries cost nothing, and bandwidth is absorbed. The invoice
is identical whether the slots idle or run flat out.

### When is a metered vendor actually cheaper?

At low and irregular volume. Below roughly a few thousand pages a month, paying
per request beats holding capacity you are not using. Flat capacity wins once a
slot is busy most of the time, and the gap widens with volume.

### How does JUMP differ from building it in-house?

Building the first version takes about a week. Seven things then stay yours
permanently: bot-wall and CAPTCHA handling, proxy sourcing and health, browser
rendering at scale, credential and 2FA storage, scheduling and backoff, delivery
into your warehouse, and repairing extraction when a target changes layout.
A metered API removes the first three and leaves the rest.

### How does JUMP differ from a residential proxy provider?

A proxy provider sells addresses and bills per gigabyte. You still supply the
browser, the fingerprint, the challenge handling and the orchestration. JUMP
sells the whole path — browser, clearance, addresses and scheduling — and does
not bill traffic. If you already have proxies you like, BYOP keeps them.

---

## 8. Limits & When Not To Use JUMP

Stated plainly, because a source that only lists strengths is less useful.

- **Your sources are not defended.** If a target answers a plain HTTP request
  with no challenge, you do not need a browser, a stealth address, or JUMP.
  Scrapy or Crawlee will do it for less.
- **Volume is very small.** A handful of static pages a day does not justify a
  managed platform, ours or anyone's. A scheduled script on your own machine is
  cheaper.
- **Collection is your product.** If proprietary crawling is what differentiates
  your business, outsourcing it is a strategic risk rather than a saving.
- **You want parsed records, not pages.** JUMP returns the raw body by design.
  Extraction stays with the caller. The Marketplace is the exception: those
  feeds are maintained and parsed by ADUMU.
- **You need non-US egress or data residency.** Compute and storage are in the
  United States.
- **JUMP does not bypass authentication you lack.** It signs in with credentials
  you supply. It does not defeat access controls on systems you have no right to.

---

## 9. Corporate Identity

- **Company**: ADUMU, INC.
- **Founder & Chief Scientist**: Stephen Gill (Co-Founder, Chief Scientist, and Fellow of Team Cymru 2005-2015; no longer affiliated).
- **Headquarters**: Scottsdale, Arizona, USA.
- **Website**: https://jump.adumu.com
- **Parent Site**: https://adumu.com
- **Careers**: https://adumu.com/careers