Project setup

1. Copy the source/ directory into your project, for example at src/cloudflare-sdk/.

2. In tsconfig.json, ensure moduleResolution is node16 or bundler, and strict is enabled:

{
  "compilerOptions": {
    "target": "ES2020",
    "module": "CommonJS",
    "moduleResolution": "node",
    "strict": true,
    "esModuleInterop": true,
    "paths": {
      "cloudflare-sdk": ["./src/cloudflare-sdk/index.ts"],
      "cloudflare-sdk/*": ["./src/cloudflare-sdk/*"]
    }
  }
}

3. Set the required environment variable before running your application:

export CLOUDFLARE_API_TOKEN="your_token_here"
# Optional alternatives:
export CLOUDFLARE_API_KEY="your_global_key"
export CLOUDFLARE_API_EMAIL="user@example.com"

4. Import the client from the local source path:

import Cloudflare from './src/cloudflare-sdk/index';

5. Instantiate the client. The apiToken defaults to process.env.CLOUDFLARE_API_TOKEN if omitted.

Public API

Cloudflare (default export)

import Cloudflare from './src/cloudflare-sdk/index';

const client = new Cloudflare({
  apiToken?: string;       // defaults to CLOUDFLARE_API_TOKEN env var
  apiKey?: string;         // alternative: global API key
  apiEmail?: string;       // required when using apiKey
  baseURL?: string;        // override API base URL
  timeout?: number;        // request timeout in ms (default: 60000)
  maxRetries?: number;     // automatic retries on 429/5xx (default: 2)
});

The root client exposes every Cloudflare product as a property (e.g., client.zones, client.kv, client.dns, client.r2). Use this when you need a single long-lived client instance shared across your application.

toFile

import { toFile } from './src/cloudflare-sdk/uploads';

const file: File = await toFile(
  source: Buffer | Uint8Array | ReadableStream | Blob,
  filename?: string,
  options?: { type?: string }
): Promise<File>;

Converts arbitrary binary sources into a File object suitable for multipart upload parameters. Use this when you have raw bytes or a stream and need to pass them to any SDK method that accepts a file upload parameter.

APIError and subclasses

import {
  APIError,
  BadRequestError,       // 400
  AuthenticationError,   // 401
  PermissionDeniedError, // 403
  NotFoundError,         // 404
  RateLimitError,        // 429
  InternalServerError,   // 500
} from './src/cloudflare-sdk/error';

// Properties available on any APIError:
error.status: number
error.message: string
error.headers: Headers

Catch APIError to handle all API failures uniformly, or catch specific subclasses for targeted error handling (e.g., exponential backoff on RateLimitError, redirect to login on AuthenticationError).

Pagination classes

import {
  V4PagePaginationResponse,
  CursorPaginationResponse,
  SinglePageResponse,
} from './src/cloudflare-sdk/pagination';

All list methods return async iterables. Use for await to transparently walk pages, or call .getPaginatedItems() for the current page's array. The SDK handles fetching subsequent pages automatically.

Working examples

Scenario - Create a DNS record

Create an A record in a zone using the fully typed dns.records.create method.

import Cloudflare from './src/cloudflare-sdk/index';
import { APIError } from './src/cloudflare-sdk/error';

const client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN });

async function addDNSRecord(zoneId: string) {
  try {
    const record = await client.dns.records.create({
      zone_id: zoneId,
      type: 'A',
      name: 'api.example.com',
      content: '192.0.2.1',
      ttl: 3600,
      proxied: false,
    });
    console.log('Created record:', record.id);
  } catch (err) {
    if (err instanceof APIError) {
      console.error(`API error ${err.status}: ${err.message}`);
    }
    throw err;
  }
}

Scenario - List all KV namespace keys with pagination

Iterate over all keys in a KV namespace without manually managing cursors.

import Cloudflare from './src/cloudflare-sdk/index';

const client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN });

async function listAllKeys(accountId: string, namespaceId: string) {
  const keys: string[] = [];

  for await (const key of await client.kv.namespaces.keys.list(namespaceId, {
    account_id: accountId,
    limit: 100,
  })) {
    keys.push(key.name);
  }

  console.log(`Total keys: ${keys.length}`);
  return keys;
}

Scenario - Upload a file to KV values

Upload a local file as a KV value using the toFile helper and fs.createReadStream.

import fs from 'fs';
import Cloudflare from './src/cloudflare-sdk/index';
import { toFile } from './src/cloudflare-sdk/uploads';
import { RateLimitError } from './src/cloudflare-sdk/error';

const client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN });

async function uploadFileToKV(
  accountId: string,
  namespaceId: string,
  key: string,
  filePath: string,
) {
  try {
    await client.kv.namespaces.values.update(namespaceId, key, {
      account_id: accountId,
      value: fs.createReadStream(filePath),
      metadata: JSON.stringify({ uploadedAt: new Date().toISOString() }),
    });
    console.log(`Uploaded ${key} successfully`);
  } catch (err) {
    if (err instanceof RateLimitError) {
      console.warn('Rate limited; back off and retry');
    }
    throw err;
  }
}

Scenario - Create a Cloudflare zone

Provision a new zone under an account with typed request parameters.

import Cloudflare, { type ZoneCreateParams } from './src/cloudflare-sdk/index';

const client = new Cloudflare({ apiToken: process.env.CLOUDFLARE_API_TOKEN });

async function createZone(accountId: string, domainName: string) {
  const params: ZoneCreateParams = {
    account: { id: accountId },
    name: domainName,
    type: 'full',
  };

  const zone = await client.zones.create(params);
  console.log(`Zone created: ${zone.id} (status: ${zone.status})`);
  return zone;
}

File walkthrough

• _shims/ - Detects the runtime environment and exports the correct fetch, File, Request, Response, and FormData implementations. Do not import this directly; core.ts consumes it.
• internal/qs/ - Standalone query-string serializer supporting nested objects, arrays, and RFC1738/RFC3986 encoding. Used by core.ts to serialize URL query parameters.
• resources/ - Each subdirectory is one Cloudflare product. Every file follows the pattern: a class extending APIResource with methods that call this._client.get/post/put/delete. Index files barrel-export types.
• shims/ - Thin public wrappers around _shims allowing consumers to import and register custom fetch implementations (e.g., for testing or edge runtimes).
• core.ts - Houses APIClient with get(), post(), put(), patch(), delete() methods, retry logic with exponential backoff, streaming response support, and header/auth management.
• error.ts - Defines APIError and all HTTP-status-specific subclasses. APIError.generate() is used internally to produce the right subclass from a raw response.
• index.ts - Instantiates and wires the top-level Cloudflare class with all resource namespaces attached as properties. This is the consumer entry point.
• pagination.ts - Generic AbstractPage<T> base class and concrete implementations (V4PagePagination, CursorPagination, SinglePage) that make list results async-iterable.
• resource.ts - APIResource base class storing a reference to the root client; all resource namespaces extend this.
• resources.ts - Single barrel file re-exporting every named resource class for convenience imports.
• uploads.ts - toFile utility and multipart form construction helpers used when request parameters include file data.
• version.ts - Exports the SDK version string used in the User-Agent header.

Common pitfalls and fixes

• Missing CLOUDFLARE_API_TOKEN at runtime: The constructor will throw if neither apiToken, apiKey, nor their env vars are present; always validate env vars at app startup.
• ESM/CJS interop errors with node-fetch: node-fetch v3 is ESM-only; pin to node-fetch@2 if your project uses CommonJS ("type": "commonjs" in package.json).
• AbortController is not defined on Node < 15: Install and globally assign abort-controller before importing the SDK: global.AbortController = require('abort-controller').
• Pagination methods returning only the first page: Always use for await or call .iterPages() on list results; calling .list() and accessing .result directly gives only the first page.
• Type errors on resource params with strict TypeScript: Ensure "strict": true and "esModuleInterop": true in tsconfig.json; the SDK uses conditional types that require strict mode to resolve correctly.
• formdata-node version conflicts: If another dependency brings in a different FormData global, the multipart shim may break; explicitly import FormData from formdata-node and pass it via the shim registration before constructing the client.

Vibe-coding prompt template

I have dropped the Cloudflare TypeScript SDK source into `src/cloudflare-sdk/` in my project.
The entry point is `src/cloudflare-sdk/index.ts` and exports the default `Cloudflare` client class
along with all resource namespaces (dns, kv, zones, r2, accounts, workers, pages, etc.).

Please read `USAGE.md` and `src/cloudflare-sdk/index.ts` for the full public API surface.
The upstream package this was taken from is `user@example.com`.

My project is a Node.js/TypeScript Express application. I need you to:
1. Install all required dependencies listed in USAGE.md.
2. Create a `src/cloudflare.ts` singleton that instantiates the `Cloudflare` client using
   `process.env.CLOUDFLARE_API_TOKEN`.
3. Implement the following feature using real SDK methods from `src/cloudflare-sdk/`:
   [DESCRIBE YOUR FEATURE HERE - e.g., "list all DNS records for a zone and return them as JSON
   from a GET /dns/:zoneId endpoint"]
4. Add proper error handling using the `APIError` subclasses from `src/cloudflare-sdk/error.ts`.
5. Use `for await` for any paginated list calls.
6. Show me the updated `tsconfig.json` if any path aliases are needed.

Do not invent SDK methods. Only use exports visible in `src/cloudflare-sdk/index.ts`
and the resource index files under `src/cloudflare-sdk/resources/`.

License and credit

The source is generated from the Cloudflare OpenAPI specification using Stainless. The upstream package is cloudflare published by Cloudflare, Inc. License terms are MIT; see source/LICENSE if present in the distributed archive, or refer to the upstream repository for the authoritative license file.

This product’s unique contribution is clean room implementation of valuable code block into AVCP compatible standard.

Hướng dẫn cài đặt đầy đủ và prompt tích hợp sẽ mở khóa sau khi mua.

Feathers Full-Stack REST and Real-Time API Framework

Automation, Utilities & Developer Tools

Miễn phí