chargebee 3.26.0 → 3.28.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+### v3.28.0 (2026-06-30)
+* * *
+
+### New Features
+* Added an optional `telemetryAdapter` config hook for tracing Chargebee API calls via OpenTelemetry (or any APM). When unconfigured, the SDK skips all telemetry work — no behavior change for existing integrations.
+* Each API call emits one CLIENT span (`chargebee.{resource}.{operation}`) with OpenTelemetry HTTP semantic-convention attributes plus `chargebee.*` attributes, and injects W3C trace context (`traceparent`) into outbound requests for distributed tracing.
+* Exposed `TelemetryAdapter`, `RequestTelemetryContext`, `RequestTelemetryResult`, `RequestTelemetryError`, `RequestTelemetryHandle` types and the `TelemetryAttributeKeys` constant from the CJS and ESM entry points.
+* Added a ready-to-use OpenTelemetry adapter via the `chargebee/telemetry/otel` subpath. `@opentelemetry/api` is an optional peer dependency and is not bundled — install it in your app to use this adapter.
+
+### Enhancements:
+- **Zod-backed request validation** — Set `enableValidation: true` in the client configuration to validate outgoing request parameters against each endpoint's generated Zod schema before the API call is sent. Invalid payloads raise `ChargebeeZodValidationError`, which carries the offending `actionName` and the original `ZodError` (including `issues` and `flatten()`) for inspection.
+- **Runtime dependency** — Added [`zod`](https://www.npmjs.com/package/zod) (v4) as a runtime dependency to support request validation.
+
+
 ### v3.26.0 (2026-06-12)
 * * *
 ### New Resources:
@@ -34,7 +48,6 @@
 - `updated_at` and `created_at` have been added as new values to enum query parameter `sort_by.desc` in [`list_omnichannel_subscriptions`](https://apidocs.chargebee.com/docs/api/omnichannel_subscriptions/list-omnichannel-subscriptions) of [`OmnichannelSubscription`](https://apidocs.chargebee.com/docs/api/omnichannel_subscriptions).
 
 
-
 ### v3.25.0 (2026-06-08)
 * * *
 ### New Attributes:

package/README.md

@@ -124,6 +124,45 @@ try {
 }
 ```
 
+### Request parameter validation (Zod)
+
+When `enableValidation` is set to `true`, the SDK validates parameters for **every** API request against Zod schemas **before** the HTTP call is made. If you omit the params object on a call, it is validated as `{}`. This is **off by default**. Schemas are included for API actions that support them; actions without a bundled schema behave as usual.
+
+```typescript
+import Chargebee, { ChargebeeZodValidationError } from 'chargebee';
+
+const chargebee = new Chargebee({
+  site: '{{site}}',
+  apiKey: '{{api-key}}',
+  enableValidation: true,
+});
+
+try {
+  await chargebee.customer.create({
+    id: 'a'.repeat(100),
+    auto_collection: 'invalid',
+  });
+} catch (err) {
+  if (err instanceof ChargebeeZodValidationError) {
+    console.error(err.message);
+    console.error(err.actionName);
+    console.error(err.zodError.issues);
+  } else {
+    throw err;
+  }
+}
+```
+
+Invalid parameters produce a `ChargebeeZodValidationError`. The error message lists every problem (field path and message). You can also inspect `actionName` (the API action, for example `create`) and `zodError` (Zod’s `ZodError`, including `issues`) for structured handling.
+
+**Example message:**
+
+```text
+ChargebeeZodValidationError: [Chargebee] Validation failed for 'create': id: Too big: expected string to have <=50 characters; auto_collection: Invalid option: expected one of "on"|"off"
+```
+
+The same `ChargebeeZodValidationError` shape applies to any action with a schema when parameters are invalid (for example bad filters or limits on `list`).
+
 ### Using filters in the List API
 
 For pagination, `offset` is the parameter that is being used. The value used for this parameter must be the value returned for `next_offset` parameter in the previous API call.
@@ -563,6 +602,98 @@ const chargebee = new Chargebee({
 
 These examples demonstrate how to implement and inject custom clients using `axios` and `ky`, respectively.
 
+### Telemetry (OpenTelemetry)
+
+Optional. Pass a `telemetryAdapter` when you want Chargebee API calls traced in your observability stack (Datadog, Splunk, Honeycomb, Jaeger, etc.). The SDK ships a ready-to-use OpenTelemetry adapter, so for most setups you only need to add `@opentelemetry/api` and wire the adapter on the client.
+
+`@opentelemetry/api` is an **optional peer dependency** — it is not bundled with `chargebee` and is only loaded when you import the adapter, so a plain `import 'chargebee'` stays dependency-free.
+
+The SDK builds standardized span attributes (`ctx.startAttributes`, `result.endAttributes`) following the stable [OpenTelemetry HTTP semantic conventions](https://opentelemetry.io/docs/specs/semconv/http/http-spans/) (`url.full`, `http.request.method`, `http.response.status_code`, `server.address`, `error.type`) plus Chargebee-specific `chargebee.*` attributes — use them as-is so spans render correctly in your APM and stay consistent across SDKs.
+
+Spans are named `chargebee.{resource}.{operation}` (e.g. `chargebee.subscription.create`).
+
+#### Quick start (built-in adapter)
+
+```bash
+npm install chargebee @opentelemetry/api @opentelemetry/sdk-node @opentelemetry/exporter-trace-otlp-http
+```
+
+Configure OpenTelemetry once at app startup. Exporting (endpoint, service name, credentials) is driven entirely by your OpenTelemetry runtime and the standard `OTEL_*` environment variables — the adapter just uses the globally registered tracer:
+
+```typescript
+// instrumentation.ts — node --require ./instrumentation.js app.js
+import { NodeSDK } from '@opentelemetry/sdk-node';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+
+new NodeSDK({
+  serviceName: process.env.OTEL_SERVICE_NAME ?? 'billing-service',
+  traceExporter: new OTLPTraceExporter({
+    url: process.env.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT ?? 'http://localhost:4318/v1/traces',
+  }),
+}).start();
+```
+
+Then import the ready-to-use adapter and pass it on client initialization:
+
+```typescript
+import Chargebee from 'chargebee';
+import otelDefaultAdapter from 'chargebee/telemetry/otel';
+
+const chargebee = new Chargebee({
+  site: '{{site}}',
+  apiKey: '{{api-key}}',
+  telemetryAdapter: otelDefaultAdapter,
+});
+```
+
+That's it — every SDK call now emits a `chargebee.<resource>.<operation>` CLIENT span that attaches to the active OpenTelemetry context (or starts a root span), with W3C trace context propagated to Chargebee. Spans are exported by your own OpenTelemetry setup, so they flow to whatever backend you've configured (Datadog, Splunk, Honeycomb, Jaeger, etc.) — refer to your APM vendor's OpenTelemetry/OTLP documentation for exporter endpoints.
+
+#### Custom adapter (advanced)
+
+To customize behavior (different tracer name, extra attributes, a non-OpenTelemetry backend, etc.), implement `TelemetryAdapter` yourself instead of importing the built-in adapter:
+
+```typescript
+import Chargebee, {
+  type TelemetryAdapter,
+  type RequestTelemetryContext,
+  type RequestTelemetryResult,
+} from 'chargebee';
+import { context, propagation, trace, SpanKind, SpanStatusCode, type Span } from '@opentelemetry/api';
+
+class OtelTelemetryAdapter implements TelemetryAdapter<Span> {
+  private readonly tracer = trace.getTracer('chargebee-node');
+
+  onRequestStart(ctx: RequestTelemetryContext, requestHeaders: Record<string, string | number>): Span {
+    const span = this.tracer.startSpan(ctx.spanName, {
+      kind: SpanKind.CLIENT,
+      attributes: ctx.startAttributes,
+    });
+    propagation.inject(trace.setSpan(context.active(), span), requestHeaders);
+    return span;
+  }
+
+  onRequestEnd(span: Span | void, result: RequestTelemetryResult) {
+    if (!span) return;
+    for (const [key, value] of Object.entries(result.endAttributes)) {
+      span.setAttribute(key, value);
+    }
+    if (result.error) {
+      span.recordException(new Error(result.error.message));
+      span.setStatus({ code: SpanStatusCode.ERROR, message: result.error.message });
+    } else {
+      span.setStatus({ code: SpanStatusCode.OK });
+    }
+    span.end();
+  }
+}
+
+const chargebee = new Chargebee({
+  site: '{{site}}',
+  apiKey: '{{api-key}}',
+  telemetryAdapter: new OtelTelemetryAdapter(),
+});
+```
+
 ## Feedback
 
 If you find any bugs or have any questions / feedback, open an issue in this repository or reach out to us on dx@chargebee.com

package/cjs/RequestWrapper.js

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RequestWrapper = void 0;
 const util_js_1 = require("./util.js");
+const index_js_1 = require("./telemetry/index.js");
 const coreCommon_js_1 = require("./coreCommon.js");
 const node_buffer_1 = require("node:buffer");
+const chargebeeZodValidationError_js_1 = require("./chargebeeZodValidationError.js");
+const validationLoader_js_1 = require("./validationLoader.js");
 class RequestWrapper {
     constructor(args, apiCall, envArg) {
         this.getRequest = () => {
@@ -23,6 +26,17 @@ class RequestWrapper {
         }
         return idParam;
     }
+    /**
+     * Validate parameters against the action's Zod schema when enableValidation is true.
+     * Query params are validated as `params ?? {}`; body params are validated when `params` is non-null.
+     * Throws a descriptive error listing every validation violation.
+     */
+    static _validateParams(params, schema, actionName) {
+        const result = schema.safeParse(params);
+        if (!result.success) {
+            throw new chargebeeZodValidationError_js_1.ChargebeeZodValidationError(actionName, result.error);
+        }
+    }
     static parseRetryAfter(retryAfter) {
         if (!retryAfter)
             return null;
@@ -32,9 +46,28 @@ class RequestWrapper {
         }
         return null;
     }
+    _buildRequestUrl(env, urlIdParam, params) {
+        let path = (0, util_js_1.getApiURL)(env, this.apiCall.urlPrefix, this.apiCall.urlSuffix, urlIdParam);
+        if (this.apiCall.httpMethod === 'GET') {
+            let requestParams = params;
+            if (typeof requestParams === 'undefined' || requestParams === null) {
+                requestParams = {};
+            }
+            const queryParam = this.apiCall.isListReq
+                ? (0, util_js_1.encodeListParams)((0, util_js_1.serialize)(requestParams))
+                : (0, util_js_1.encodeParams)((0, util_js_1.serialize)(requestParams));
+            path += '?' + queryParam;
+        }
+        return new URL(path, `${env.protocol}://${(0, util_js_1.getHost)(env, this.apiCall.subDomain)}${env.port ? `:${env.port}` : ''}`);
+    }
     async request() {
         let _env = {};
         (0, util_js_1.extend)(true, _env, this.envArg);
+        // Class-based adapters (e.g. OpenTelemetry) keep methods on the prototype;
+        // deep extend only copies own enumerable properties, so preserve by reference.
+        if (this.envArg.telemetryAdapter !== undefined) {
+            _env.telemetryAdapter = this.envArg.telemetryAdapter;
+        }
         const env = _env;
         const retryConfig = Object.assign({ enabled: false, maxRetries: 3, delayMs: 200, retryOn: [500, 502, 503, 504] }, env.retryConfig);
         const urlIdParam = this.apiCall.hasIdInUrl ? this.args[0] : null;
@@ -42,6 +75,20 @@ class RequestWrapper {
             ? this.args[1]
             : this.args[0];
         let headers = this.apiCall.hasIdInUrl ? this.args[2] : this.args[1];
+        // Lazy-load Zod schema when enableValidation is true
+        if (env.enableValidation &&
+            this.apiCall.resourceKey &&
+            this.apiCall.actionName) {
+            const schema = await (0, validationLoader_js_1.getSchema)(this.apiCall.resourceKey, this.apiCall.actionName);
+            if (schema) {
+                if (this.apiCall.httpMethod === 'GET') {
+                    RequestWrapper._validateParams(params !== null && params !== void 0 ? params : {}, schema, this.apiCall.methodName);
+                }
+                else if (params != null) {
+                    RequestWrapper._validateParams(params, schema, this.apiCall.methodName);
+                }
+            }
+        }
         Object.assign(this.httpHeaders, headers);
         if (this.apiCall.httpMethod === 'POST' &&
             !this.httpHeaders['chargebee-idempotency-key'] &&
@@ -50,19 +97,43 @@ class RequestWrapper {
             retryConfig.enabled) {
             this.httpHeaders['chargebee-idempotency-key'] = (0, util_js_1.generateUUIDv4)();
         }
+        const telemetryAdapter = env.telemetryAdapter;
+        const telemetryHeaders = {};
+        const requestStartTime = Date.now();
+        const requestUrl = this._buildRequestUrl(env, urlIdParam, params);
+        // No telemetry adapter configured => skip all telemetry work (zero overhead).
+        let telemetryHandle;
+        if (telemetryAdapter !== undefined) {
+            const telemetryContext = (0, index_js_1.buildRequestTelemetryContext)({
+                resource: this.apiCall.resource,
+                operation: this.apiCall.methodName,
+                httpMethod: this.apiCall.httpMethod,
+                httpUrl: `${requestUrl.origin}${requestUrl.pathname}`,
+                serverAddress: requestUrl.hostname,
+                chargebeeSite: env.site,
+                chargebeeApiVersion: (0, index_js_1.resolveChargebeeApiVersion)(env.apiPath),
+                sdkVersion: env.clientVersion,
+                requestHeaders: this.httpHeaders,
+            });
+            try {
+                telemetryHandle = telemetryAdapter.onRequestStart(telemetryContext, telemetryHeaders);
+            }
+            catch (err) {
+                const message = err instanceof Error
+                    ? err.message
+                    : 'Unknown telemetry adapter error';
+                (0, util_js_1.log)(env, {
+                    level: 'ERROR',
+                    message: `Telemetry adapter onRequestStart failed: ${message}. Continuing without telemetry.`,
+                });
+                telemetryHandle = undefined;
+            }
+        }
         const makeRequest = async (attempt = 0) => {
-            let path = (0, util_js_1.getApiURL)(env, this.apiCall.urlPrefix, this.apiCall.urlSuffix, urlIdParam);
             let requestParams = params;
             if (typeof requestParams === 'undefined' || requestParams === null) {
                 requestParams = {};
             }
-            if (this.apiCall.httpMethod === 'GET') {
-                const queryParam = this.apiCall.isListReq
-                    ? (0, util_js_1.encodeListParams)((0, util_js_1.serialize)(requestParams))
-                    : (0, util_js_1.encodeParams)((0, util_js_1.serialize)(requestParams));
-                path += '?' + queryParam;
-                requestParams = {};
-            }
             const jsonKeys = this.apiCall.jsonKeys;
             let data = null;
             if (this.apiCall.httpMethod !== 'GET') {
@@ -70,7 +141,7 @@ class RequestWrapper {
                     ? JSON.stringify(requestParams)
                     : (0, util_js_1.encodeParams)(requestParams, undefined, undefined, undefined, jsonKeys);
             }
-            const requestHeaders = Object.assign({}, this.httpHeaders);
+            const requestHeaders = Object.assign(Object.assign({}, this.httpHeaders), telemetryHeaders);
             if (data && data.length) {
                 (0, util_js_1.extend)(true, requestHeaders, {
                     'Content-Length': node_buffer_1.Buffer.byteLength(data, 'utf8'),
@@ -90,8 +161,7 @@ class RequestWrapper {
             if (attempt > 0) {
                 requestHeaders['X-CB-Retry-Attempt'] = attempt.toString();
             }
-            const url = new URL(path, `${env.protocol}://${(0, util_js_1.getHost)(env, this.apiCall.subDomain)}${env.port ? `:${env.port}` : ''}`);
-            const request = new Request(url, {
+            const request = new Request(requestUrl, {
                 method: this.apiCall.httpMethod,
                 body: data || undefined,
                 headers: this._createHeaders(requestHeaders),
@@ -153,7 +223,55 @@ class RequestWrapper {
                 return await withRetry(retryCount + 1, startTime);
             }
         };
-        const promise = withRetry(0, Date.now());
+        const runWithTelemetry = async (adapter) => {
+            var _a;
+            try {
+                const result = await withRetry(0, requestStartTime);
+                const httpStatusCode = typeof (result === null || result === void 0 ? void 0 : result.httpStatusCode) === 'number'
+                    ? result.httpStatusCode
+                    : 200;
+                try {
+                    adapter.onRequestEnd(telemetryHandle, (0, index_js_1.buildRequestTelemetryResult)({
+                        httpStatusCode,
+                        durationMs: Date.now() - requestStartTime,
+                    }));
+                }
+                catch (err) {
+                    const message = err instanceof Error
+                        ? err.message
+                        : 'Unknown telemetry adapter error';
+                    (0, util_js_1.log)(env, {
+                        level: 'ERROR',
+                        message: `Telemetry adapter onRequestEnd failed: ${message}.`,
+                    });
+                }
+                return result;
+            }
+            catch (err) {
+                const httpStatusCode = (_a = (0, index_js_1.extractHttpStatusCode)(err)) !== null && _a !== void 0 ? _a : 500;
+                const telemetryError = (0, index_js_1.extractRequestTelemetryError)(err);
+                try {
+                    adapter.onRequestEnd(telemetryHandle, (0, index_js_1.buildRequestTelemetryResult)({
+                        httpStatusCode,
+                        durationMs: Date.now() - requestStartTime,
+                        error: telemetryError,
+                    }));
+                }
+                catch (telemetryErr) {
+                    const message = telemetryErr instanceof Error
+                        ? telemetryErr.message
+                        : 'Unknown telemetry adapter error';
+                    (0, util_js_1.log)(env, {
+                        level: 'ERROR',
+                        message: `Telemetry adapter onRequestEnd failed: ${message}.`,
+                    });
+                }
+                throw err;
+            }
+        };
+        const promise = telemetryAdapter !== undefined
+            ? runWithTelemetry(telemetryAdapter)
+            : withRetry(0, requestStartTime);
         return (0, util_js_1.callbackifyPromise)(promise);
     }
     _createHeaders(httpHeaders) {

package/cjs/chargebee.cjs.js

@@ -4,6 +4,8 @@ const createChargebee_js_1 = require("./createChargebee.js");
 const FetchClient_js_1 = require("./net/FetchClient.js");
 const handler_js_1 = require("./resources/webhook/handler.js");
 const auth_js_1 = require("./resources/webhook/auth.js");
+const index_js_1 = require("./telemetry/index.js");
+const chargebeeZodValidationError_js_1 = require("./chargebeeZodValidationError.js");
 const httpClient = new FetchClient_js_1.FetchHttpClient();
 const Chargebee = (0, createChargebee_js_1.CreateChargebee)(httpClient);
 module.exports = Chargebee;
@@ -18,3 +20,6 @@ module.exports.WebhookError = handler_js_1.WebhookError;
 module.exports.WebhookAuthenticationError = handler_js_1.WebhookAuthenticationError;
 module.exports.WebhookPayloadValidationError = handler_js_1.WebhookPayloadValidationError;
 module.exports.WebhookPayloadParseError = handler_js_1.WebhookPayloadParseError;
+module.exports.TelemetryAttributeKeys = index_js_1.TelemetryAttributeKeys;
+// Export validation error class
+module.exports.ChargebeeZodValidationError = chargebeeZodValidationError_js_1.ChargebeeZodValidationError;

package/cjs/chargebee.cjs.worker.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebhookPayloadParseError = exports.WebhookPayloadValidationError = exports.WebhookAuthenticationError = exports.WebhookError = exports.basicAuthValidator = exports.WebhookContentType = exports.WebhookEventType = void 0;
 const createChargebee_js_1 = require("./createChargebee.js");
 const FetchClient_js_1 = require("./net/FetchClient.js");
+const chargebeeZodValidationError_js_1 = require("./chargebeeZodValidationError.js");
 const httpClient = new FetchClient_js_1.FetchHttpClient();
 const Chargebee = (0, createChargebee_js_1.CreateChargebee)(httpClient);
 module.exports = Chargebee;
@@ -19,3 +20,4 @@ Object.defineProperty(exports, "WebhookError", { enumerable: true, get: function
 Object.defineProperty(exports, "WebhookAuthenticationError", { enumerable: true, get: function () { return handler_js_2.WebhookAuthenticationError; } });
 Object.defineProperty(exports, "WebhookPayloadValidationError", { enumerable: true, get: function () { return handler_js_2.WebhookPayloadValidationError; } });
 Object.defineProperty(exports, "WebhookPayloadParseError", { enumerable: true, get: function () { return handler_js_2.WebhookPayloadParseError; } });
+module.exports.ChargebeeZodValidationError = chargebeeZodValidationError_js_1.ChargebeeZodValidationError;

package/cjs/chargebeeZodValidationError.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChargebeeZodValidationError = void 0;
+class ChargebeeZodValidationError extends Error {
+    constructor(actionName, zodError) {
+        var _a;
+        const messages = zodError.issues
+            .map((e) => `${e.path.join('.')}: ${e.message}`)
+            .join('; ');
+        super(`[Chargebee] Validation failed for '${actionName}': ${messages}`);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = 'ChargebeeZodValidationError';
+        this.actionName = actionName;
+        this.zodError = zodError;
+        (_a = Error.captureStackTrace) === null || _a === void 0 ? void 0 : _a.call(Error, this, this.constructor);
+    }
+}
+exports.ChargebeeZodValidationError = ChargebeeZodValidationError;

package/cjs/createChargebee.js

@@ -1,4 +1,15 @@
 "use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreateChargebee = void 0;
 const RequestWrapper_js_1 = require("./RequestWrapper.js");
@@ -10,10 +21,14 @@ const handler_js_1 = require("./resources/webhook/handler.js");
 const CreateChargebee = (httpClient) => {
     const Chargebee = function (conf) {
         this._env = Object.assign({}, environment_js_1.Environment);
-        (0, util_js_1.extend)(true, this._env, conf);
+        const { telemetryAdapter, httpClient: configHttpClient } = conf, confToMerge = __rest(conf, ["telemetryAdapter", "httpClient"]);
+        (0, util_js_1.extend)(true, this._env, confToMerge);
         // @ts-ignore
         this._env.httpClient =
-            conf.httpClient != null ? conf.httpClient : httpClient;
+            configHttpClient != null ? configHttpClient : httpClient;
+        if (telemetryAdapter !== undefined) {
+            this._env.telemetryAdapter = telemetryAdapter;
+        }
         this._buildResources();
         this._endpoints = api_endpoints_js_1.Endpoints;
         // Initialize webhooks handler with auto-configured Basic Auth (if env vars are set)
@@ -85,6 +100,7 @@ const CreateChargebee = (httpClient) => {
                 for (let apiIdx = 0; apiIdx < apiCalls.length; apiIdx++) {
                     const metaArr = apiCalls[apiIdx];
                     const apiCall = {
+                        resource: res,
                         methodName: metaArr[0],
                         httpMethod: metaArr[1],
                         urlPrefix: metaArr[2],
@@ -96,6 +112,11 @@ const CreateChargebee = (httpClient) => {
                         jsonKeys: metaArr[7],
                         options: metaArr[8],
                     };
+                    if (this._env.enableValidation) {
+                        // Store resource and action for lazy schema loading in RequestWrapper
+                        apiCall.resourceKey = res;
+                        apiCall.actionName = metaArr[0];
+                    }
                     this[res][apiCall.methodName] = this._createApiFunc(apiCall, this._env);
                 }
             }

package/cjs/environment.js

@@ -11,7 +11,7 @@ exports.Environment = {
     hostSuffix: '.chargebee.com',
     apiPath: '/api/v2',
     timeout: DEFAULT_TIME_OUT,
-    clientVersion: 'v3.26.0',
+    clientVersion: 'v3.28.0',
     port: DEFAULT_PORT,
     timemachineWaitInMillis: DEFAULT_TIME_MACHINE_WAIT,
     exportWaitInMillis: DEFAULT_EXPORT_WAIT,