Cloudflare

https://github.com/cloudflare/cloudflare-docs
Admin
Cloudflare Docs is an open-source documentation project that allows community feedback and...
Tokens:7,430,042
Snippets:54,574
Trust Score:9.3
Update:1 day ago
Show doc for...
Tokens:
Raw
### Install dependencies and start development server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/style-guide/contributions.mdx

Installs the required package dependencies and starts the local documentation development server with hot reloading.

```bash
pnpm install
pnpm run dev
```

--------------------------------

### Install dependencies and run dev server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/getting-started/quick-start.mdx

Navigate into the newly created project folder, install dependencies, and start the local development server.

```sh
cd agents-starter
npm install
npm run dev
```

--------------------------------

### Install Vite globally and start development server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/quickstart.mdx

Use this alternative command when running the project from the ready-made template.

```bash
npm i -g vite && npm run dev
```

--------------------------------

### Example response with ssl.settings

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-for-platforms/cloudflare-for-saas/performance/early-hints-for-saas.mdx

This is an example response from the GET request. It shows the ssl.settings object with early_hints set to "off". Copy the complete object to modify it.

```json
{
  "ssl": {
    "settings": {
      "ciphers": [
        "ECDHE-ECDSA-AES128-GCM-SHA256",
        "ECDHE-RSA-AES128-GCM-SHA256"
      ],
      "early_hints": "off",
      "http2": "on",
      "min_tls_version": "1.2",
      "tls_1_3": "on"
    }
  }
}
```

--------------------------------

### Prepare the Pocket Radio repository checkout

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/sfu/examples/embedded-devices.mdx

Clone the realtime-examples repository, navigate to the esp32-radio directory, execute the setup script, and copy the example credentials configuration file.

```sh
git clone https://github.com/cloudflare/realtime-examples.git
cd realtime-examples/esp32-radio
make setup
cp .credential.env.example .credential.env
```

--------------------------------

### Install AWS SDK and fetch R2 object in Go

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/r2/examples/authenticate-r2-auth-tokens.mdx

Install the aws-sdk-go-v2 packages using go get, then run the script with go run main.go. Replace <YOUR_BUCKET_NAME> and objectKey with your bucket name and existing file key.

```sh
go get github.com/aws/aws-sdk-go-v2
go get github.com/aws/aws-sdk-go-v2/config
go get github.com/aws/aws-sdk-go-v2/credentials
go get github.com/aws/aws-sdk-go-v2/service/s3
```

```go
   	package main

    import (
  	  "context"
  	  "fmt"
  	  "io"
  	  "log"
  	  "github.com/aws/aws-sdk-go-v2/aws"
  	  "github.com/aws/aws-sdk-go-v2/config"
  	  "github.com/aws/aws-sdk-go-v2/service/s3"
    )

    func main() {
	    cfg, err := config.LoadDefaultConfig(context.TODO())
	    if err != nil {
		    log.Fatalf("Unable to load SDK config, %v", err)
	    }

	    // Create an S3 client
	    client := s3.NewFromConfig(cfg)

	    // Specify the object key
	    bucket := "<YOUR_BUCKET_NAME>"
	    objectKey := "pfp.jpg"

	    // Fetch the object
	    output, err := client.GetObject(context.TODO(), &s3.GetObjectInput{
		    Bucket: aws.String(bucket),
		    Key:    aws.String(objectKey),
	    })
	    if err != nil {
		    log.Fatalf("Unable to fetch object, %v", err)
	    }
	    defer output.Body.Close()

	    fmt.Println("Successfully fetched the object")

	    // Process the object content as needed
	    // For example, to save the file:
	    // file, err := os.Create("ingested_0001.parquet")
	    // if err != nil {
	    // 	log.Fatalf("Unable to create file, %v", err)
	    // }
	    // defer file.Close()
	    // _, err = io.Copy(file, output.Body)
	    // if err != nil {
	    // 	log.Fatalf("Unable to write file, %v", err)
	    // }

	    // Or to read the content:
	    content, err := io.ReadAll(output.Body)
	    if err != nil {
		    log.Fatalf("Unable to read object content, %v", err)
	    }
	    fmt.Printf("Object content length: %d bytes\n", len(content))
    }
```

--------------------------------

### Install Go SDK with go get

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/flagship/sdk/index.mdx

Download and install the Cloudflare Flagship OpenFeature SDK module for Go server applications.

```sh
go get github.com/cloudflare/flagship/sdks/go
```

--------------------------------

### Run the Dynamic Workers Starter locally

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/dynamic-workers/examples/dynamic-workers-starter.mdx

Install dependencies and start the local development server. Use these commands to run the starter template on your machine.

```sh
npm install
npm run dev
```

--------------------------------

### Install and start HTTPD on EC2

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ssl/origin-configuration/authenticated-origin-pull/aws-alb-integration.mdx

Installs the HTTPD daemon using yum and starts the service on an Amazon Linux EC2 instance. Run this during target instance setup before configuring the ALB target group.

```bash
sudo yum install -y httpd
sudo systemctl start httpd
```

--------------------------------

### Install cloudflared service to run at login

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/cloudflare-one/tunnel/locally-managed/as-a-service/macos.mdx

Installs Cloudflare Tunnel as a launch agent that starts whenever you log in, using the configuration in ~/.cloudflared/.

```sh
cloudflared service install
```

--------------------------------

### Open GuiDBedit.exe from the installed SmartConsole version and build

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-wan/configuration/third-party/check-point.mdx

Use this path to launch GuiDBedit.exe. Replace {VERSION} and {BUILD} with the installed SmartConsole version and build, for example R82.10\82.10.9900.426.

```txt
C:\Program Files (x86)\CheckPoint\SmartConsole\{VERSION}\{BUILD}\GuiDBedit.exe
```

--------------------------------

### Ask your agent to install cf and update AGENTS.md

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cf/agents.mdx

Prompt you can give your agent to perform the cf setup for you, including installing the CLI and adding the cf preference line to your user-level AGENTS.md or CLAUDE.md file.

```txt
Install the Cloudflare CLI with `npm install -g cf`. Then add this line to my
user-level AGENTS.md or CLAUDE.md file: "When interacting with Cloudflare, use
the cf CLI unless the project has a Wrangler configuration file."
```

--------------------------------

### Create and start an Agents starter project with create-cloudflare

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/index.mdx

Initialize a new agent project using the cloudflare/agents-starter template, install dependencies, and start the local development server. Uses Workers AI by default with no API keys required.

```sh
npx create-cloudflare@latest --template cloudflare/agents-starter
cd agents-starter && npm install
npm run dev
```

--------------------------------

### Create project and install dependencies

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/examples/voice-agent.mdx

Scaffolds a new project using the cloudflare/agents-starter template and installs the @cloudflare/voice package.

```sh
npm create cloudflare@latest voice-agent -- --template cloudflare/agents-starter
cd voice-agent
npm install @cloudflare/voice
```

--------------------------------

### Install cloudflared service to run at boot

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/cloudflare-one/tunnel/locally-managed/as-a-service/macos.mdx

Installs Cloudflare Tunnel as a launch daemon requiring root privileges, starting on system boot and using configuration in /etc/cloudflared.

```sh
sudo cloudflared service install
```

--------------------------------

### Example JRE path for Android Studio

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

This is an example of the JRE path shown in Android Studio's About dialog. Use it to set the JAVA_HOME environment variable for certificate installation.

```txt
/Applications/Android Studio.app/Contents/jbr/Contents/Home
```

--------------------------------

### Clone custom headers example template

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/how-to/add-custom-http-headers.mdx

Clones the custom-headers-example repository and installs its dependencies with npm.

```bash
git clone https://github.com/cloudflare/custom-headers-example
cd custom-headers-example
npm install
```

--------------------------------

### Run the quickstart script

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ai-search/get-started/python.mdx

Executes quickstart.py to run the instance creation, upload, and search sequence.

```sh
python quickstart.py
```

--------------------------------

### Install and initialize RealtimeKit via NPM or CDN

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/core/index.mdx

Install the core SDK via npm or load it via CDN script tag, then initialize using RealtimeKitClient.init.

```bash
npm i @cloudflare/realtimekit
```

```html
<script src="https://cdn.jsdelivr.net/npm/@cloudflare/realtimekit@latest/dist/browser.js"></script>
```

```js
	// Skip this import if you are using the CDN. RealtimeKitClient is available globally.
	import RealtimeKitClient from "@cloudflare/realtimekit";

	const authToken = <auth-token>;

	const meetingDefaultOptions = {
		audio: true,
		video: true,
	};

	RealtimeKitClient.init({
	  authToken,
	  defaults: meetingDefaultOptions,
	}).then((meeting) => {
		// next - meeting.join();
	});
```

--------------------------------

### Install Claude Code CLI

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-setup/claude-code.mdx

Install the Claude Code CLI using the official install script. For Windows, Homebrew, WinGet, or npm, see the Claude Code setup guide.

```bash
curl -fsSL https://claude.ai/install.sh | bash
```

--------------------------------

### Install the Codex CLI with npm

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-setup/codex.mdx

Installs the Codex CLI globally. macOS and Linux are fully supported; use WSL2 on Windows. For Homebrew or other install methods, see the Codex CLI setup guide.

```bash
npm install -g @openai/codex
```

--------------------------------

### Create install-tunnel.tftpl startup script

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/cloudflare-one/terraform/startup-script.mdx

Creates a Terraform template file and defines a startup script that installs Docker, deploys an HTTPBin test container, and starts the `cloudflared` service with the provided tunnel token.

```sh
touch install-tunnel.tftpl
```

```bash
# Script to install Cloudflare Tunnel and Docker resources

# Docker configuration
cd /tmp
sudo apt-get install software-properties-common
# Retrieving the docker repository for this OS
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu bionic stable"
# The OS is updated and docker is installed
sudo apt update -y && sudo apt upgrade -y
sudo apt install docker docker-compose -y
# Add the HTTPBin application and run it on localhost:8080.
cat > /tmp/docker-compose.yml << "EOF"
version: '3'
services:
  httpbin:
    image: kennethreitz/httpbin
    restart: always
    container_name: httpbin
    ports:
      - 8080:80

  cloudflared:
    image: cloudflare/cloudflared:latest
    restart: always
    container_name: cloudflared
    command: tunnel run --token ${tunnel_token}
EOF
cd /tmp
sudo docker-compose up -d
```

--------------------------------

### Navigate to the project directory

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/tutorials/postgres.mdx

Switch into the newly created `postgres-tutorial` directory after scaffolding the Worker application.

```sh
cd postgres-tutorial
```

--------------------------------

### Specify a framework version in package.json

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/configuration/build-image.mdx

Use this to pin a specific framework version in the project's package manager configuration file. For example, Gatsby version 5.13.7 will be installed using npm install when the build starts, unless already cached.

```json
"dependencies": {
	"gatsby": "^5.13.7",
}
```

--------------------------------

### Launch interactive setup wizard with Wrangler CLI

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/basin-pipelines/sinks/manage-sinks.mdx

Use the interactive setup wizard to configure a stream, sink, and pipeline together.

```bash
<PackageManagers type="exec" pkg="wrangler" args={"basin pipelines setup"} />
```

--------------------------------

### Initialize a new Sphinx project with sphinx-quickstart

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/framework-guides/deploy-a-sphinx-site.mdx

Runs sphinx-quickstart inside the active virtual environment and answers prompts for directory setup, project name, author, release, and language.

```sh
sphinx-quickstart
```

```sh output
Separate source and build directories (y/n) [n]: Y
Project name: <Your project name>
Author name(s): <You Author Name>
Project release []: <You can accept default here or provide a version>
Project language [en]: <You can accept en here or provide a regional language code>
```

--------------------------------

### Install Browser and PiHarness on a Durable Object

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/tools/browser.mdx

Defines a BrowserAssistant Durable Object that installs a Browser and PiHarness, letting Pi choose when to call the browser tool. Lifecycle starts both components and provides their storage. The example uses one named assistant for demonstration; in an application, choose an object name for each authenticated user or workspace.

```ts
import { DurableObject } from "cloudflare:workers";
import { createModels } from "@earendil-works/pi-ai/models";
import { createRegistry, Harness } from "@earendil-works/pi-durable";
import { Browser, browserRun } from "agents/browser";
import { browserTool } from "agents/browser/pi";
import { PiHarness } from "agents/harness/pi";
import { Lifecycle } from "agents/lifecycle";
import { createAI } from "agents/models/pi-ai";

export { CodemodeRuntime } from "agents/browser";

export class BrowserAssistant extends DurableObject<Env> {
	ai = createAI({ binding: this.env.AI });
	browser = new Browser({ provider: browserRun(this.env.BROWSER) });
	registry = createRegistry();

	harness = new PiHarness({
		harness: ({ storage, context }) => {
			const models = createModels();
			models.setProvider(this.ai.provider);
			this.registry.install({
				name: "browser",
				tools: [
					browserTool({
						ctx: this.ctx,
						browser: this.browser,
						loader: this.env.LOADER,
					}),
				],
			});
			return Harness.open(
				storage,
				{ models, registry: this.registry },
				context,
			);
		},
		defaults: { model: this.ai("@cf/moonshotai/kimi-k2.7-code") },
	});

	lifecycle = Lifecycle.install(this).use(this.browser).use(this.harness);

	async ask(prompt: string) {
		const { text } = await this.harness.prompt(prompt);
		return text;
	}
}

export default {
	async fetch(request: Request, env: Env) {
		const assistant = env.BrowserAssistant.getByName("demo");
		const text = await assistant.ask(await request.text());
		return Response.json({ text });
	},
} satisfies ExportedHandler<Env>;
```

--------------------------------

### Create and run agents-starter project

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/changelog/agents/2025-03-18-npm-i-agents.mdx

Initialize and run the `agents-starter` example template using `npm create cloudflare@latest`.

```sh
# Install it
$ npm create cloudflare@latest agents-starter -- --template="cloudflare/agents-starter"
# Run it
$ npm run start
```

--------------------------------

### Install the Cloudflare SDK

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-for-platforms/workers-for-platforms/reference/platform-examples.mdx

Install the official Cloudflare npm package before using the TypeScript SDK examples.

```sh
npm install cloudflare
```

--------------------------------

### Install OpenCode

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-setup/opencode.mdx

Install OpenCode using the official installation script.

```bash
curl -fsSL https://opencode.ai/install | bash
```

--------------------------------

### Test D1 Worker Binding APIs in index.js

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/d1/worker-api/index.mdx

Routes incoming requests based on the URL pathname to test various D1 Worker Binding API methods such as run, raw, first, batch, exec, and withSession. Replaces the contents of index.js following the initial Get started setup.

```js
// D1 API Playground - Test each D1 Worker Binding API method
// Change the URL pathname to test different methods (e.g., /RUN, /RAW, /FIRST)
export default {
	async fetch(request, env) {
	  const { pathname } = new URL(request.url);

		// Sample data for testing
		const companyName1 = `Bs Beverages`;
		const companyName2 = `Around the Horn`;

		// Prepare reusable statements
		const stmt = env.DB.prepare(`SELECT * FROM Customers WHERE CompanyName = ?`);
		const stmtMulti = env.DB.prepare(`SELECT * FROM Customers; SELECT * FROM Customers WHERE CompanyName = ?`);
		const session = env.DB.withSession("first-primary")
		const sessionStmt = session.prepare(`SELECT * FROM Customers WHERE CompanyName = ?`);

      // Test D1PreparedStatement::run - returns full D1Result object
      if (pathname === `/RUN`){
    	const returnValue = await stmt.bind(companyName1).run();
    	return Response.json(returnValue);

      // Test D1PreparedStatement::raw - returns array of arrays
    } else if (pathname === `/RAW`){
    	const returnValue = await stmt.bind(companyName1).raw();
    	return Response.json(returnValue);

      // Test D1PreparedStatement::first - returns first row only
    } else if (pathname === `/FIRST`){
    	const returnValue = await stmt.bind(companyName1).first();
    	return Response.json(returnValue);

      // Test D1Database::batch - execute multiple statements
    } else if (pathname === `/BATCH`) {
    	const batchResult = await env.DB.batch([
    		stmt.bind(companyName1),
    		stmt.bind(companyName2)
    	]);
    	return Response.json(batchResult);

      // Test D1Database::exec - execute raw SQL without parameters
    } else if (pathname === `/EXEC`){
    	const returnValue = await env.DB.exec(`SELECT * FROM Customers WHERE CompanyName = "Bs Beverages"`);
    	return Response.json(returnValue);

      // Test D1 Sessions API with read replication
    } else if (pathname === `/WITHSESSION`){
    	const returnValue = await sessionStmt.bind(companyName1).run();
    	console.log("You're now using D1 Sessions!")
    	return Response.json(returnValue);
    }

      // Default response with instructions
      return new Response(
    	`Welcome to the D1 API Playground!
    	\nChange the URL to test the various methods inside your index.js file.`,
      );
    },

};
```

--------------------------------

### Create and initialize project with uv and dependencies

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/basin-catalog/get-started.mdx

Sets up a project directory, initializes a uv environment creating .venv and pyproject.toml, and adds marimo, pyiceberg, pyarrow, and pandas.

```bash
mkdir r2-data-catalog-notebook

```

```bash
cd r2-data-catalog-notebook

```

```text
uv init

```

```py
uv add marimo pyiceberg pyarrow pandas

```

--------------------------------

### Index sample document via /setup endpoint

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ai-search/agent-sdks/ai-sdk.mdx

Triggers document indexing at the /setup route. The first indexing run may take a minute or two before returning a completed status and key.

```sh
curl http://localhost:8787/setup
```

```json
{ "key": "caching.md", "status": "completed" }
```

--------------------------------

### Clone and install privacypass-ts repository

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/privacy-pass/getting-started.mdx

Clone the repository and install dependencies before running the local Privacy Pass examples.

```sh
git clone https://github.com/cloudflare/privacypass-ts.git
cd privacypass-ts
npm ci
```

--------------------------------

### Example output of wrangler check startup

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/wrangler/commands/workers.mdx

Shows the bundle size and local startup profile metrics: profile window, sampled time, active time, idle time, and sample count.

```txt
Bundle: 42.31 KiB / gzip: 11.24 KiB

Local startup profile:
  Profile window: 25.2 ms
  Sampled time: 24.8 ms
  Active: 18.4 ms (including 1.2 ms garbage collection)
  Idle: 6.4 ms
  Samples: 25
```

--------------------------------

### Create a new project using eleventy-base-blog

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/framework-guides/deploy-an-eleventy-site.mdx

Clones the `eleventy-base-blog` starter repository into a local directory, navigates into it, and installs project dependencies.

```sh
git clone https://github.com/11ty/eleventy-base-blog.git my-blog-name
cd my-blog-name
npm install
```

--------------------------------

### Install and Run cloudflared on macOS

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/setup/replace-vpn/device-to-network.mdx

Installs the cloudflared connector via Homebrew and starts the service using the provided tunnel token on macOS.

```sh
brew install cloudflared && sudo cloudflared service install <YOUR_TUNNEL_TOKEN>
```

--------------------------------

### Create the HTML entry point

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/demos/chatgpt-app.mdx

Sets up index.html with the root container element and imports the app entry script.

```html
<!doctype html>
<html>
	<head>
		<!--RUNTIME_CONFIG-->
	</head>
	<body>
		<div id="root" style="font-family: verdana"></div>
		<script type="module" src="/src/app.tsx"></script>
	</body>
</html>
```

--------------------------------

### Fetch WebVTT caption file with cURL and example response

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/stream/edit-videos/adding-captions.mdx

Make a GET request to download the WebVTT caption file for a specific language tag on a video. The example shows both the request and the returned WebVTT text structure.

```bash
curl \
-H 'Authorization: Bearer <API_TOKEN>' \
https://api.cloudflare.com/client/v4/accounts/<ACCOUNT_ID>/stream/<VIDEO_UID>/captions/<LANGUAGE_TAG>/vtt
```

```text
WEBVTT

1
00:00:00.000 --> 00:00:01.560
This is an example of

2
00:00:01.560 --> 00:00:03.880
a WebVTT caption response.
```

--------------------------------

### Example Gemfile structure

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/migrations/migrating-jekyll-from-github-pages.mdx

Complete example of a configured Gemfile including source, git_source, and the github-pages gem.

```ruby
# frozen_string_literal: true

source "https://rubygems.org"

git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }

# gem "rails"
gem "github-pages", group: :jekyll_plugins
```

--------------------------------

### Install Cloudflare package using go get (Go)

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pulumi/tutorial/hello-world.mdx

Downloads and adds the Pulumi Cloudflare SDK module to your Go project.

```sh
go get github.com/pulumi/pulumi-cloudflare/sdk/v3/go/cloudflare
```

```sh output
go: downloading github.com/pulumi/pulumi-cloudflare ...
```

--------------------------------

### Run a preparation command on startup with onStart() and output()

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/containers/guides/execute-commands.mdx

Use the onStart() lifecycle hook to execute commands when a Container starts. process.output() buffers standard output and standard error as separate ArrayBuffer instances.

```typescript
import { Container } from "@cloudflare/containers";

export class MyContainer extends Container {
	override async onStart() {
		const process = await this.ctx.container.exec([
			"node",
			"scripts/prepare.js",
		]);
		const output = await process.output();
		const decoder = new TextDecoder();

	if (output.exitCode !== 0) {
		throw new Error(
			`Container preparation failed: ${decoder.decode(output.stderr)}`,
		);
	}

	console.log(decoder.decode(output.stdout));
    }

}
```

--------------------------------

### Start a background process and check status

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/sandbox/commands/run-background-processes.mdx

Sends a POST request to start a process named ticker and a GET request to verify its running state and process ID.

```sh
curl https://<YOUR_WORKER>.<YOUR_SUBDOMAIN>.workers.dev/processes/ticker --request POST
curl https://<YOUR_WORKER>.<YOUR_SUBDOMAIN>.workers.dev/processes/ticker
```

```json
{ "state": "running", "pid": 354 }
```

--------------------------------

### Render APIRequest with various methods and options

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/style-guide/build-the-page/components/api-request.mdx

Examples demonstrating PUT, DELETE, POST, and GET requests with JSON payloads, form data, code highlighting, and parameter substitutions.

```mdx
import { APIRequest } from "~/components";

<APIRequest
	path="/zones/{zone_id}/api_gateway/settings/schema_validation"
	method="PUT"
	json={{
		validation_default_mitigation_action: "block",
	}}
	code={{
		mark: [5, "block"],
	}}
	roles="Domain"
/>

<APIRequest
	path="/zones/{zone_id}/hostnames/settings/{setting_id}/{hostname}"
	method="DELETE"
	parameters={{
		setting_id: "ciphers",
	}}
/>

<APIRequest
	path="/accounts/{account_id}/images/v2/direct_upload"
	method="POST"
	form={{
		requireSignedURLs: true,
		metadata: '{"key":"value"}',
	}}
/>

<APIRequest
	path="/zones/{zone_id}/cloud_connector/rules"
	method="PUT"
	json={[
		{
			expression: 'http.request.uri.path wildcard "/images/*"',
			provider: "cloudflare_r2",
			description: "Connect to R2 bucket containing images",
			parameters: {
				host: "mybucketcustomdomain.example.com",
			},
		},
	]}
/>

<APIRequest
	path="/zones/{zone_id}/page_shield/scripts"
	method="GET"
	parameters={{
		direction: "asc",
	}}
/>
```

--------------------------------

### Install the RealtimeKit recording SDK

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/recording-guide/create-record-app-using-sdks.mdx

Install the RealtimeKit recording SDK package using npm.

```js
npm i @cloudflare/realtimekit-recording-sdk
```

--------------------------------

### Initialize a new Hexo project

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/pages/framework-guides/deploy-a-hexo-site.mdx

Run `hexo init` to scaffold a new Hexo project and navigate into the project directory.

```sh
hexo init my-hexo-site
cd my-hexo-site
```

--------------------------------

### Install Cloudflare root certificate in Alpine-based containers during runtime with Docker Compose

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Add this service definition to your docker-compose.yml to install the Cloudflare root certificate at runtime for Alpine-based containers. The certificate is mounted as a volume and the entrypoint installs it before starting the app.

```yaml
version: '3'
services:
	alpine-app:
		image: alpine:3.18
 		volumes:
 			- certs/certificate.pem:/usr/local/share/ca-certificates/certificate.pem
 		entrypoint: /bin/sh -c "apk add --no-cache ca-certificates && update-ca-certificates && app start"
```

--------------------------------

### Complete Wrangler Configuration Example

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/queues/tutorials/handle-rate-limits/index.mdx

Complete Wrangler configuration file example with project metadata, nodejs compatibility, and queue bindings configured for rate limits.

```jsonc
{
	"$schema": "./node_modules/wrangler/config-schema.json",
	"name": "resend-rate-limit-queue",
	"main": "src/index.ts",
	"upload_source_maps": true,
	"compatibility_date": "$today",
	"compatibility_flags": [
		"nodejs_compat"
		],
	"queues": {
		"producers": [
			{
				"binding": "EMAIL_QUEUE",
				"queue": "rate-limit-queue"
			}
		],
		"consumers": [
			{
				"queue": "rate-limit-queue",
				"max_batch_size": 2,
				"max_batch_timeout": 10,
				"max_retries": 3
			}
		]
	}
}
```

--------------------------------

### Complete wrangler.jsonc example for an agents project

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/runtime/operations/configuration.mdx

Full configuration covering static assets, Durable Object bindings, exports with sqlite storage, AI binding, and observability. Use as a starting template for an agents Worker.

```jsonc
{
	"$schema": "node_modules/wrangler/config-schema.json",
	"name": "my-agent-app",
	"main": "src/server.ts",
	"upload_source_maps": true,
	"compatibility_date": "$today",
	"compatibility_flags": ["nodejs_compat"],

	// Static assets (optional)
	"assets": {
		"directory": "public",
		"binding": "ASSETS",
	},

	// Durable Object bindings for agents
	"durable_objects": {
		"bindings": [
			{
				"name": "MyAgent",
				"class_name": "MyAgent",
			},
			{
				"name": "ChatAgent",
				"class_name": "ChatAgent",
			},
		],
	},

  // Provision storage for each agent class
	"exports": {
		"MyAgent": {
			"type": "durable-object",
			"storage": "sqlite",
		},
		"ChatAgent": {
			"type": "durable-object",
			"storage": "sqlite",
		},
	},

	// AI binding (optional, for Workers AI)
	"ai": {
		"binding": "AI",
	},

	// Observability (recommended)
	"observability": {
		"enabled": true,
	},
}
```

--------------------------------

### Install Cloudflare root certificate in Debian-based containers during runtime with Docker Compose

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Add this service definition to your docker-compose.yml to install the Cloudflare root certificate at runtime for Debian-based containers. The certificate is mounted as a volume and the entrypoint installs it before starting the app.

```yaml
version: '3'
services:
	debian-app:
		image: debian:12
 		volumes:
 			- certs/certificate.pem:/usr/local/share/ca-certificates/certificate.crt
 		entrypoint: /bin/sh -c "apt-get update && apt-get install -y ca-certificates && update-ca-certificates && app start"
```

--------------------------------

### Start Trino Docker container with R2 catalog

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/basin-catalog/config-examples/trino.mdx

Prepares the catalog directory, copies the configuration file, and starts a Trino Docker container mounting the catalog volume.

```bash
# Create a local directory for the catalog configuration
mkdir -p trino-catalog

# Place your r2.properties file in the catalog directory
cp r2.properties trino-catalog/

# Run Trino with the catalog configuration
docker run -d \
  --name trino-r2 \
  -p 8080:8080 \
  -v $(pwd)/trino-catalog:/etc/trino/catalog \
  trinodb/trino:latest
```

--------------------------------

### Start local development server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workers/framework-guides/web-apps/more-web-frameworks/analog.mdx

Runs the local development server to preview the Analog application locally.

```npm
npm run dev
```

```pnpm
pnpm run dev
```

```yarn
yarn run dev
```

```bun
bun run dev
```

--------------------------------

### Deploy static assets directory with interactive setup

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/changelog/workers/2025-09-09-interactive-wrangler-assets.mdx

Deploys a static site directory using the simplified command syntax, initiating interactive prompts for project setup.

```bash
wrangler deploy dist
# Interactive prompts handle the rest as shown in the example flow below
```

--------------------------------

### Install Apache and create test HTML page

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/networks/connectors/cloudflare-tunnel/deployment-guides/azure.mdx

Updates apt package repositories, installs the Apache HTTP server, and writes a sample test landing page to verify web server connectivity.

```bash
apt update

apt -y install apache2

cat <<EOF > /var/www/html/index.html
<html><body><h1>Hello Cloudflare!</h1>
<p>This page was created for a Cloudflare demo.</p>
</body></html>
EOF
```

--------------------------------

### Install Cloudflare root certificate in Red Hat-based containers during runtime with Docker Compose

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Add this service definition to your docker-compose.yml to install the Cloudflare root certificate at runtime for Red Hat-based containers. The certificate is mounted as a volume and the entrypoint installs it before starting the app.

```yaml
version: '3'
services:
	redhat-app:
		image: registry.access.redhat.com/ubi9/ubi:latest
 		volumes:
 			- certs/certificate.pem:/etc/pki/ca-trust/source/anchors/certificate.pem
 		entrypoint: /bin/sh -c "dnf install -y ca-certificates && update-ca-trust extract && app start"
```

--------------------------------

### Start development server with npm

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/durable-objects/tutorials/build-a-seat-booking-app.mdx

Run the local development server to serve the application frontend at http://localhost:8787.

```bash
npm run dev
```

--------------------------------

### Check Wrangler version

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/workflows/build/local-development.mdx

Confirm that Wrangler v3.89.0 or higher is installed before starting local development.

```sh
# Confirm we are using wrangler v3.89.0+
npx wrangler --version
```

```sh output
⛅️ wrangler 3.89.0
```

--------------------------------

### Initialize partition using lunacm

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ssl/keyless-ssl/hardware-security-modules/ibm-cloud-hsm.mdx

Run lunacm from your virtual server and initialize the assigned partition with a label and domain password.

```txt
vm$ lunacm
LunaCM v7.1.0-379. Copyright (c) 2006-2017 SafeNet.

    Available HSMs:

    Slot Id ->              0
    Label ->
    Serial Number ->        XXXXXXXXXXXXX
    Model ->                LunaSA 7.0.0
    Firmware Version ->     7.0.1
    Configuration ->        Luna User Partition With SO (PW) Signing With Cloning Mode
    Slot Description ->     Net Token Slot


    Current Slot Id: 0

lunacm:>partition init -label KeylessSSL -domain cloudflare

  Enter password for Partition SO: ********

  Re-enter password for Partition SO: ********

  You are about to initialize the partition.
  All contents of the partition will be destroyed.

  Are you sure you wish to continue?

  Type 'proceed' to continue, or 'quit' to quit now ->proceed

Command Result : No Error
```

--------------------------------

### Run Docker Compose container

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/team-and-resources/devices/user-side-certificates/manual-deployment.mdx

Run this command to start the container with the certificate installed at runtime.

```sh
docker-compose up
```

--------------------------------

### Query rewriting system prompt configuration example

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ai-search/configuration/retrieval/system-prompt.mdx

Guides the model to extract core concepts, add synonyms, remove filler words, and output only the rewritten search terms for vector database retrieval.

```text
You are a search query optimizer for vector database searches. Your task is to reformulate user queries into more effective search terms.

Given a user's search query, you must:
1. Identify the core concepts and intent
2. Add relevant synonyms and related terms
3. Remove irrelevant filler words
4. Structure the query to emphasize key terms
5. Include technical or domain-specific terminology if applicable

Provide only the optimized search query without any explanations, greetings, or additional commentary.

Example input: "how to fix a bike tire that's gone flat"
Example output: "bicycle tire repair puncture fix patch inflate maintenance flat tire inner tube replacement"

Constraints:
- Output only the enhanced search terms
- Keep focus on searchable concepts
- Include both specific and general related terms
- Maintain all important meaning from original query
```

--------------------------------

### Get Custom Hostname SSL Settings Response Example

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-for-platforms/cloudflare-for-saas/security/certificate-management/enforce-mtls.mdx

Example response from retrieving a custom hostname's SSL configuration. Note the `type` and `method` values, which are required for the subsequent PATCH request.

```json
{
  "success": true,
  "result": {
    "id": "<CUSTOM_HOSTNAME_ID>",
    "ssl": {
      "id": "<CERTIFICATE_ID>",
      "bundle_method": "ubiquitous",
      "certificate_authority": "<CERTIFICATE_AUTHORITY>",
      "custom_certificate": "",
      "custom_csr_id": "",
      "custom_key": "",
      "expires_on": "",
      "hosts": [
        "app.example.com",
        "*.app.example.com"
      ],
      "issuer": "",
      "method": "http",
      "settings": {},
      "signature": "SHA256WithRSA",
      "type": "dv",
      "uploaded_on": "2020-02-06T18:11:23.531995Z",
      "validation_errors": [
        {
          "message": "SERVFAIL looking up CAA for app.example.com"
        }
      ],
      "validation_records": [
        {
          "emails": [
            "administrator@example.com",
            "webmaster@example.com"
          ],
          "http_body": "ca3-574923932a82475cb8592200f1a2a23d",
          "http_url": "http://app.example.com/.well-known/pki-validation/ca3-da12a1c25e7b48cf80408c6c1763b8a2.txt",
          "txt_name": "_acme-challenge.app.example.com",
          "txt_value": "810b7d5f01154524b961ba0cd578acc2"
        }
      ],
      "wildcard": false
    },
  }
}
```

--------------------------------

### Install cloudflared service on Windows

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/partials/cloudflare-one/tunnel/install-and-run-tunnel.mdx

Installs cloudflared as a service from an administrator Command Prompt on Windows.

```txt
cloudflared.exe service install <TUNNEL_TOKEN>
```

--------------------------------

### Install dependencies

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/examples/browser-agent.mdx

Install the required Agents SDK, codemode, AI SDK, and Zod packages.

```sh
npm install agents @cloudflare/codemode ai zod
```

--------------------------------

### Set up environment variables

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/hyperdrive/examples/connect-to-postgres/postgres-drivers-and-libraries/prisma-orm.mdx

Add your database connection string to the .env file created by Prisma.

```txt
DATABASE_URL="postgres://user:password@host:port/database"
```

--------------------------------

### Install cf-terraforming

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/turnstile/get-started/widget-management/terraform.mdx

Installs the cf-terraforming CLI tool using Go.

```shell
go install github.com/cloudflare/cf-terraforming/cmd/cf-terraforming@latest
```

--------------------------------

### Install Vibe CLI

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agent-setup/vibe.mdx

Install the Vibe command-line interface on macOS or Linux using the official installer script.

```bash
curl -LsSf https://mistral.ai/vibe/install.sh | bash
```

--------------------------------

### GET Custom Hostname Details response example

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-for-platforms/cloudflare-for-saas/security/certificate-management/enforce-mtls.mdx

Response from a GET request to the Custom Hostname Details endpoint. Use it to retrieve the current ssl.settings object before making a PATCH request, so unrelated settings are not reset.

```json
  "success": true,
  "result": {
    "id": "<CUSTOM_HOSTNAME_ID>",
    "ssl": {
      "id": "<CERTIFICATE_ID>",
      "bundle_method": "ubiquitous",
      "certificate_authority": "<CERTIFICATE_AUTHORITY>",
      "custom_certificate": "",
      "custom_csr_id": "",
      "custom_key": "",
      "expires_on": "",
      "hosts": [
        "app.example.com",
        "*.app.example.com"
      ],
      "issuer": "",
      "method": "http",
      "settings": {},
      "signature": "SHA256WithRSA",
      "type": "dv",
      "uploaded_on": "2020-02-06T18:11:23.531995Z",
      "validation_errors": [
        {
          "message": "SERVFAIL looking up CAA for app.example.com"
        }
      ],
      "validation_records": [
        {
          "emails": [
            "administrator@example.com",
            "webmaster@example.com"
          ],
          "http_body": "ca3-574923932a82475cb8592200f1a2a23d",
          "http_url": "http://app.example.com/.well-known/pki-validation/ca3-da12a1c25e7b48cf80408c6c1763b8a2.txt",
          "txt_name": "_acme-challenge.app.example.com",
          "txt_value": "810b7d5f01154524b961ba0cd578acc2"
        }
      ],
      "wildcard": false
    },
  }
```

--------------------------------

### env.BROWSER.launch()

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/browser-run/reference/browser-binding-api.mdx

Performs session acquisition and connection capability setup in a single call.

```APIDOC
### env.BROWSER.launch()

#### Description
Performs the acquire and connection-capability steps in one call when separating acquisition from connection is not needed.

#### Return Value
Returns a `Promise<Connection>` resolving to an object containing:
- `sessionId` (string) - The Browser Run session ID.
- `webSocket` (Fetcher) - A session-pinned `Fetcher` used to open a CDP connection.
- `targets` (Array, optional) - The target list if returned.

#### Example
```ts
const session = await env.BROWSER.launch();
const response = await session.webSocket.fetch(
  "https://browser-binding.invalid",
  { headers: { Upgrade: "websocket" } }
);
```
```

--------------------------------

### Create installation script file

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/tutorials/deploy-client-headless-linux.mdx

Sets file creation permissions and opens a new shell script in Vim.

```sh
umask 077
vim install_warp.sh
```

--------------------------------

### init(client)

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/recording-guide/create-record-app-using-sdks.mdx

Initiates the SDK by providing a RealtimeKitClient object before joining the room.

```APIDOC
## init(client: RealtimeKitClient)

### Description
Initiates the SDK by providing a `RealtimeKitClient` object. Call this after creating the meeting object and before calling `meeting.joinRoom()`.

### Syntax
```js
init(client: RealtimeKitClient)
```

### Parameters
- `client` (RealtimeKitClient, required) - The RealtimeKitClient instance.
```

--------------------------------

### Use startsWith function in queries

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/analytics/analytics-engine/sql-reference/string-functions.mdx

Query examples checking if a string or dataset column starts with a specified prefix.

```sql
SELECT startsWith('prefix ...', 'prefix') AS b;
SELECT startsWith(blob1, 'prefix') AS b FROM your_dataset;
```

--------------------------------

### Get a zone ruleset response

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/ruleset-engine/rulesets-api/view.mdx

Example response returned from a GET request to `/zones/{zone_id}/rulesets/{ruleset_id}` for a zone-level phase entry point ruleset. It includes the ruleset metadata, rules configuration, version, and phase.

```json
{
	"result": {
		"id": "<RULESET_ID>",
		"name": "Zone-level phase entry point",
		"description": "Executes a managed ruleset.",
		"kind": "zone",
		"version": "3",
		"rules": [
			{
				"id": "<RULE_ID>",
				"version": "1",
				"action": "execute",
			"expression": "true",
				"action_parameters": {
					"id": "<MANAGED_RULESET_ID>"
				},
				"last_updated": "2025-03-17T15:42:37.917815Z"
			}
		],
		"last_updated": "2025-03-17T15:42:37.917815Z",
		"phase": "http_request_firewall_managed"
	},
	"success": true,
	"errors": [],
	"messages": []
}
```

--------------------------------

### RealtimeKitClient.initMedia([options], [skipAwaits], [cachedUserDetails])

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/realtime/realtimekit/core/api-reference/RealtimeKitClient.md

Static method to initialize media settings and configurations prior to or during meeting setup.

```APIDOC
### RealtimeKitClient.initMedia([options], [skipAwaits], [cachedUserDetails])

#### Description
Initializes media streams and user details for the client.

#### Parameters
- **options** (object, optional) - Media options and settings.
- **skipAwaits** (boolean, optional) - Flag to skip awaiting certain media init tasks.
- **cachedUserDetails** (object, optional) - Cached user details to use during initialization.
```

--------------------------------

### Run install script

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/cloudflare-one/tutorials/deploy-client-headless-linux.mdx

Executes the Cloudflare One Client installer script with elevated privileges.

```sh
sudo ./install_warp.sh
```

--------------------------------

### Start Local Development Server

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/r2/tutorials/summarize-pdf.mdx

Run the development server locally to preview the front-end application.

```sh
npm run dev
```

```txt output
 ⛅️ wrangler 3.80.2
-------------------

⎔ Starting local server...
[wrangler:inf] Ready on http://localhost:8787
╭───────────────────────────╮
│  [b] open a browser       │
│  [d] open devtools        │
│  [l] turn off local mode  │
│  [c] clear console        │
│  [x] to exit              │
╰───────────────────────────╯
```

--------------------------------

### Install an extension with tools and prompt sections in PiHarness

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/agents/harnesses/pi/extensions.mdx

Create a registry with `createRegistry()` and install extensions containing tools and sections in the `harness` factory before calling `Harness.open()`.

```ts
import { Agent } from "agents";
import { Type } from "@earendil-works/pi-ai";
import { createModels } from "@earendil-works/pi-ai/models";
import {
	createRegistry,
	Harness,
	type ToolRegistration,
} from "@earendil-works/pi-durable";
import { PiHarness } from "agents/harness/pi";
import { createAI } from "agents/models/pi-ai";

const WordCount = Type.Object({ text: Type.String() });

const wordCount: ToolRegistration<typeof WordCount> = {
	name: "word_count",
	description: "Count the words in a text.",
	parameters: WordCount,
	replay: "safe",
	// `text` is typed from `parameters`, which Pi validates first.
	async execute({ text }) {
		const words = text.split(/\s+/).filter(Boolean).length;
		return { content: [{ type: "text", text: String(words) }] };
	},
};

export class Editor extends Agent<Env> {
	ai = createAI({ binding: this.env.AI });
	registry = createRegistry();

	harness = new PiHarness({
		harness: ({ storage, context }) => {
			this.registry.install({
				name: "editor",
				sections: [
					{ key: "preamble", render: () => "You are an editor.", tag: false },
				],
				tools: [wordCount],
			});
			const models = createModels();
			models.setProvider(this.ai.provider);
			return Harness.open(
				storage,
				{ models, registry: this.registry },
				context,
			);
		},
		defaults: { model: this.ai("@cf/moonshotai/kimi-k2.7-code") },
	});

	constructor(ctx: DurableObjectState, env: Env) {
		super(ctx, env);
		this.lifecycle.use(this.harness);
	}
}
```

--------------------------------

### Install cloudflare-flagship using pip

Source: https://github.com/cloudflare/cloudflare-docs/blob/production/src/content/docs/flagship/sdk/python.mdx

Install the Flagship Python SDK package using pip.

```sh
pip install cloudflare-flagship
```