@shaivpidadi/trends-js 1.0.2 → 1.0.3

package/README.md

@@ -22,7 +22,6 @@ npm install @shaivpidadi/trends-js
 - Get interest by region data
 - Get related topics for any keyword
 - Get related queries for any keyword
-- Get combined related data (topics + queries)
 - TypeScript support
 - Promise-based API
 
@@ -113,8 +112,6 @@ const suggestions = await GoogleTrendsApi.autocomplete(
   'bitcoin', // Keyword to get suggestions for
   'en-US', // Language (default: 'en-US')
 );
-
-// Returns: string[]
 ```
 
 ### Explore
@@ -124,8 +121,8 @@ Get widget data for a keyword:
 ```typescript
 const result = await GoogleTrendsApi.explore({
   keyword: 'bitcoin',
-  geo: 'US', // Default: 'US'
-  time: 'today 12-m', // Default: 'today 12-m'
+  geo: 'US' // Default: 'US',
+  time: 'today 12-m',
   category: 0, // Default: 0
   property: '', // Default: ''
   hl: 'en-US', // Default: 'en-US'
@@ -140,6 +137,7 @@ const result = await GoogleTrendsApi.explore({
 //   }>
 // }
 ```
+> **Note:** For all methods below, it is recommended to set `enableBackoff: true` in the options to automatically handle and bypass Google's rate limiting.
 
 ### Interest by Region
 
@@ -177,31 +175,20 @@ const result = await GoogleTrendsApi.interestByRegion({
 // }
 ```
 
-Example with multiple keywords and regions:
-
-```typescript
-const result = await GoogleTrendsApi.interestByRegion({
-  keyword: ['wine', 'peanuts'],
-  geo: ['US-CA', 'US-VA'],
-  startTime: new Date('2024-01-01'),
-  endTime: new Date(),
-  resolution: 'CITY',
-  enableBackoff: true
-});
-```
-
 ### Related Topics
 
 Get related topics for any keyword:
 
 ```typescript
 const result = await GoogleTrendsApi.relatedTopics({
-  keyword: 'artificial intelligence', // Required
-  geo: 'US', // Optional - defaults to 'US'
-  time: 'now 1-d', // Optional - defaults to 'now 1-d'
+  keyword: 'artificial intelligence',
+  startTime: new Date('2024-01-01'),
+  endTime: new Date(),
   category: 0, // Optional - defaults to 0
+  geo: 'US', // Optional - defaults to 'US'
   property: '', // Optional - defaults to ''
   hl: 'en-US', // Optional - defaults to 'en-US'
+  enableBackoff: true // Optional - defaults to false
 });
 
 // Result structure:
@@ -232,12 +219,13 @@ Get related queries for any keyword:
 
 ```typescript
 const result = await GoogleTrendsApi.relatedQueries({
-  keyword: 'machine learning', // Required
-  geo: 'US', // Optional - defaults to 'US'
-  time: 'now 1-d', // Optional - defaults to 'now 1-d'
-  category: 0, // Optional - defaults to 0
-  property: '', // Optional - defaults to ''
-  hl: 'en-US', // Optional - defaults to 'en-US'
+  keyword: 'machine learning',
+  geo: 'US',
+  startTime: new Date('2024-01-01'),
+  endTime: new Date(),
+  category: 0,
+  hl: 'en-US',
+  enableBackoff: true // Optional - defaults to false
 });
 
 // Result structure:
@@ -258,37 +246,14 @@ const result = await GoogleTrendsApi.relatedQueries({
 // }
 ```
 
-### Combined Related Data
-
-Get both related topics and queries in a single call:
-
-```typescript
-const result = await GoogleTrendsApi.relatedData({
-  keyword: 'blockchain', // Required
-  geo: 'US', // Optional - defaults to 'US'
-  time: 'now 1-d', // Optional - defaults to 'now 1-d'
-  category: 0, // Optional - defaults to 0
-  property: '', // Optional - defaults to ''
-  hl: 'en-US', // Optional - defaults to 'en-US'
-});
-
-// Result structure:
-// {
-//   data: {
-//     topics: Array<RelatedTopic>,
-//     queries: Array<RelatedQuery>
-//   }
-// }
-```
-
 ## API Reference
 
 ### DailyTrendsOptions
 
 ```typescript
 interface DailyTrendsOptions {
-  geo?: string; // Default: 'US'
-  lang?: string; // Default: 'en'
+  geo?: string;
+  lang?: string;
 }
 ```
 
@@ -297,7 +262,7 @@ interface DailyTrendsOptions {
 ```typescript
 interface RealTimeTrendsOptions {
   geo: string;
-  trendingHours?: number; // Default: 4
+  trendingHours?: number;
 }
 ```
 
@@ -306,11 +271,11 @@ interface RealTimeTrendsOptions {
 ```typescript
 interface ExploreOptions {
   keyword: string;
-  geo?: string; // Default: 'US'
-  time?: string; // Default: 'today 12-m'
-  category?: number; // Default: 0
-  property?: string; // Default: ''
-  hl?: string; // Default: 'en-US'
+  geo?: string;
+  time?: string;
+  category?: number;
+  property?: string;
+  hl?: string;
 }
 ```
 
@@ -318,64 +283,45 @@ interface ExploreOptions {
 
 ```typescript
 interface InterestByRegionOptions {
-  keyword: string | string[]; // Required - search term(s)
-  startTime?: Date; // Optional - start date
-  endTime?: Date; // Optional - end date
-  geo?: string | string[]; // Optional - geocode(s)
-  resolution?: 'COUNTRY' | 'REGION' | 'CITY' | 'DMA'; // Optional
-  hl?: string; // Optional - language code
-  timezone?: number; // Optional - timezone offset
-  category?: number; // Optional - category number
-  enableBackoff?: boolean // Optional
-}
-```
-
-### RelatedTopicsResponse
-
-```typescript
-interface RelatedTopicsResponse {
-  default: {
-    rankedList: Array<{
-      rankedKeyword: Array<{
-        topic: {
-          mid: string;
-          title: string;
-          type: string;
-        };
-        value: number;
-        formattedValue: string;
-        hasData: boolean;
-        link: string;
-      }>;
-    }>;
-  };
+  keyword: string;
+  startTime?: Date;
+  endTime?: Date;
+  geo?: string;
+  resolution?: 'COUNTRY' | 'REGION' | 'CITY' | 'DMA';
+  hl?: string;
+  timezone?: number;
+  category?: number;
+  enableBackoff?: boolean;
 }
 ```
 
-### RelatedQueriesResponse
+### RelatedTopicsOptions
 
 ```typescript
-interface RelatedQueriesResponse {
-  default: {
-    rankedList: Array<{
-      rankedKeyword: Array<{
-        query: string;
-        value: number;
-        formattedValue: string;
-        hasData: boolean;
-        link: string;
-      }>;
-    }>;
-  };
+interface RelatedTopicsOptions {
+  keyword: string;
+  geo?: string;
+  startTime?: Date;
+  endTime?: Date;
+  category?: number;
+  property?: string;
+  hl?: string;
+  enableBackoff?: boolean;
 }
 ```
 
-### RelatedData
+### RelatedQueriesOptions
 
 ```typescript
-interface RelatedData {
-  topics: Array<RelatedTopic>;
-  queries: Array<RelatedQuery>;
+interface RelatedQueriesOptions {
+  keyword: string;
+  geo?: string;
+  startTime?: Date;
+  endTime?: Date;
+  category?: number;
+  property?: string;
+  hl?: string;
+  enableBackoff?: boolean;
 }
 ```
 
@@ -383,6 +329,16 @@ interface RelatedData {
 
 ### Building
 
+```bash
+npm run build
 ```
 
+### Testing
+
+```bash
+npm test
 ```
+
+## License
+
+MIT

package/dist/cjs/constants.js

@@ -37,17 +37,17 @@ exports.GOOGLE_TRENDS_MAPPER = {
         headers: {},
     },
     [enums_js_1.GoogleTrendsEndpoints.relatedTopics]: {
-        path: '/trends/api/widgetdata/relatedtopics',
+        path: '/trends/api/widgetdata/relatedsearches',
         method: 'GET',
         host: GOOGLE_TRENDS_BASE_URL,
-        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedtopics`,
+        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedsearches`,
         headers: {},
     },
     [enums_js_1.GoogleTrendsEndpoints.relatedQueries]: {
-        path: '/trends/api/widgetdata/relatedqueries',
+        path: '/trends/api/widgetdata/relatedsearches',
         method: 'GET',
         host: GOOGLE_TRENDS_BASE_URL,
-        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedqueries`,
+        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedsearches`,
         headers: {},
     },
 };

package/dist/cjs/helpers/googleTrendsAPI.d.ts

@@ -1,4 +1,4 @@
-import { DailyTrendingTopics, DailyTrendingTopicsOptions, RealTimeTrendsOptions, ExploreOptions, ExploreResponse, InterestByRegionOptions, InterestByRegionResponse, GoogleTrendsResponse, GoogleTrendsError, RelatedTopicsResponse, RelatedQueriesResponse, RelatedData } from '../types/index.js';
+import { DailyTrendingTopics, DailyTrendingTopicsOptions, RealTimeTrendsOptions, ExploreOptions, ExploreResponse, InterestByRegionOptions, InterestByRegionResponse, GoogleTrendsResponse, GoogleTrendsError, RelatedTopicsResponse, RelatedTopicsOptions, RelatedQueriesResponse, RelatedData, RelatedQueriesOptions } from '../types/index.js';
 export declare class GoogleTrendsApi {
     /**
      * Get autocomplete suggestions for a keyword
@@ -23,8 +23,8 @@ export declare class GoogleTrendsApi {
         error: GoogleTrendsError;
     }>;
     interestByRegion({ keyword, startTime, endTime, geo, resolution, hl, timezone, category, enableBackoff }: InterestByRegionOptions): Promise<GoogleTrendsResponse<InterestByRegionResponse>>;
-    relatedTopics({ keyword, geo, time, category, property, hl, enableBackoff, }: ExploreOptions): Promise<GoogleTrendsResponse<RelatedTopicsResponse>>;
-    relatedQueries({ keyword, geo, time, category, property, hl, }: ExploreOptions): Promise<GoogleTrendsResponse<RelatedQueriesResponse>>;
+    relatedTopics({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: RelatedTopicsOptions): Promise<GoogleTrendsResponse<RelatedTopicsResponse>>;
+    relatedQueries({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: RelatedQueriesOptions): Promise<GoogleTrendsResponse<RelatedQueriesResponse>>;
     relatedData({ keyword, geo, time, category, property, hl, }: ExploreOptions): Promise<GoogleTrendsResponse<RelatedData>>;
 }
 declare const _default: GoogleTrendsApi;

package/dist/cjs/helpers/googleTrendsAPI.js

@@ -207,19 +207,21 @@ class GoogleTrendsApi {
             return { error: new GoogleTrendsError_js_1.UnknownError('Interest by region request failed') };
         }
     }
-    async relatedTopics({ keyword, geo = 'US', time = 'now 1-d', category = 0, property = '', hl = 'en-US', enableBackoff = false, }) {
+    async relatedTopics({ keyword, geo = 'US', startTime = new Date('2004-01-01'), endTime = new Date(), category = 0, property = '', hl = 'en-US', enableBackoff = false, }) {
         try {
             // Validate keyword
             if (!keyword || keyword.trim() === '') {
                 return { error: new GoogleTrendsError_js_1.InvalidRequestError('Keyword is required') };
             }
+            const keywordValue = Array.isArray(keyword) ? keyword[0] : keyword;
+            const geoValue = Array.isArray(geo) ? geo[0] : geo;
             // Step 1: Call explore to get widget data and token
+            const timeValue = `${(0, format_js_1.formatDate)(startTime)} ${(0, format_js_1.formatDate)(endTime)}`;
             const exploreResponse = await this.explore({
-                keyword,
-                geo,
-                time,
+                keyword: keywordValue,
+                geo: geoValue,
+                time: timeValue,
                 category,
-                property,
                 hl,
                 enableBackoff
             });
@@ -235,40 +237,16 @@ class GoogleTrendsApi {
             if (!relatedTopicsWidget) {
                 return { error: new GoogleTrendsError_js_1.ParseError('No related topics widget found in explore response') };
             }
+            const requestFromWidget = {
+                ...relatedTopicsWidget.request
+            };
             // Step 3: Call the related topics API with or without token
             const options = {
                 ...constants_js_1.GOOGLE_TRENDS_MAPPER[enums_js_1.GoogleTrendsEndpoints.relatedTopics],
                 qs: {
                     hl,
                     tz: '240',
-                    req: JSON.stringify({
-                        restriction: {
-                            geo: { country: geo },
-                            time: time,
-                            originalTimeRangeForExploreUrl: time,
-                            complexKeywordsRestriction: {
-                                keyword: [{
-                                        type: 'BROAD',
-                                        value: keyword
-                                    }]
-                            }
-                        },
-                        keywordType: 'ENTITY',
-                        metric: ['TOP', 'RISING'],
-                        trendinessSettings: {
-                            compareTime: time
-                        },
-                        requestOptions: {
-                            property: property,
-                            backend: 'CM',
-                            category: category
-                        },
-                        language: hl.split('-')[0],
-                        userCountryCode: geo,
-                        userConfig: {
-                            userType: 'USER_TYPE_LEGIT_USER'
-                        }
-                    }),
+                    req: JSON.stringify(requestFromWidget),
                     ...(relatedTopicsWidget.token && { token: relatedTopicsWidget.token })
                 }
             };
@@ -279,11 +257,7 @@ class GoogleTrendsApi {
                 const data = JSON.parse(text.slice(5));
                 // Return the data in the expected format
                 return {
-                    data: {
-                        default: {
-                            rankedList: data.default?.rankedList || []
-                        }
-                    }
+                    data: data.default?.rankedList || []
                 };
             }
             catch (parseError) {
@@ -300,32 +274,62 @@ class GoogleTrendsApi {
             return { error: new GoogleTrendsError_js_1.UnknownError() };
         }
     }
-    async relatedQueries({ keyword, geo = 'US', time = 'now 1-d', category = 0, property = '', hl = 'en-US', }) {
+    async relatedQueries({ keyword, geo = 'US', startTime = new Date('2004-01-01'), endTime = new Date(), category = 0, property = '', hl = 'en-US', enableBackoff = false, }) {
         try {
             // Validate keyword
             if (!keyword || keyword.trim() === '') {
-                return { error: new GoogleTrendsError_js_1.ParseError() };
+                return { error: new GoogleTrendsError_js_1.InvalidRequestError('Keyword is required') };
             }
-            const autocompleteResult = await this.autocomplete(keyword, hl);
-            if (autocompleteResult.error) {
-                return { error: autocompleteResult.error };
+            const keywordValue = Array.isArray(keyword) ? keyword[0] : keyword;
+            const geoValue = Array.isArray(geo) ? geo[0] : geo;
+            // Step 1: Call explore to get widget data and token
+            const timeValue = `${(0, format_js_1.formatDate)(startTime)} ${(0, format_js_1.formatDate)(endTime)}`;
+            const exploreResponse = await this.explore({
+                keyword: keywordValue,
+                geo: geoValue,
+                time: timeValue,
+                category,
+                hl,
+                enableBackoff
+            });
+            if ('error' in exploreResponse) {
+                return { error: exploreResponse.error };
             }
-            const relatedQueries = autocompleteResult.data?.slice(0, 10).map((suggestion, index) => ({
-                query: suggestion,
-                value: 100 - index * 10,
-                formattedValue: (100 - index * 10).toString(),
-                hasData: true,
-                link: `/trends/explore?q=${encodeURIComponent(suggestion)}&date=${time}&geo=${geo}`
-            })) || [];
-            return {
-                data: {
-                    default: {
-                        rankedList: [{
-                                rankedKeyword: relatedQueries
-                            }]
-                    }
+            if (!exploreResponse.widgets || exploreResponse.widgets.length === 0) {
+                return { error: new GoogleTrendsError_js_1.ParseError('No widgets found in explore response. This might be due to Google blocking the request, invalid parameters, or network issues.') };
+            }
+            const relatedQueriesWidget = exploreResponse.widgets.find(widget => widget.id === 'RELATED_QUERIES') || null; // Fallback to first widget if no specific one found
+            if (!relatedQueriesWidget) {
+                return { error: new GoogleTrendsError_js_1.ParseError('No related queries widget found in explore response') };
+            }
+            const requestFromWidget = {
+                ...relatedQueriesWidget.request
+            };
+            const options = {
+                ...constants_js_1.GOOGLE_TRENDS_MAPPER[enums_js_1.GoogleTrendsEndpoints.relatedQueries],
+                qs: {
+                    hl,
+                    tz: '240',
+                    req: JSON.stringify(requestFromWidget),
+                    token: relatedQueriesWidget.token
                 }
             };
+            const response = await (0, request_js_1.request)(options.url, options, enableBackoff);
+            const text = await response.text();
+            // Parse the response
+            try {
+                const data = JSON.parse(text.slice(5));
+                // Return the data in the expected format
+                return {
+                    data: data.default?.rankedList || []
+                };
+            }
+            catch (parseError) {
+                if (parseError instanceof Error) {
+                    return { error: new GoogleTrendsError_js_1.ParseError(`Failed to parse related queries response: ${parseError.message}`) };
+                }
+                return { error: new GoogleTrendsError_js_1.ParseError('Failed to parse related queries response') };
+            }
         }
         catch (error) {
             if (error instanceof Error) {

package/dist/cjs/helpers/request.js

@@ -17,14 +17,31 @@ async function runRequest(options, body, attempt) {
             res.on('data', (data) => { chunk += data; });
             res.on('end', async () => {
                 const hasSetCookie = !!res.headers['set-cookie']?.length;
+                if (hasSetCookie) {
+                    // Only keep the name=value part of the cookie, discard attributes like Expires, Path, etc.
+                    const newCookie = res.headers['set-cookie'][0].split(';')[0];
+                    cookieVal = newCookie;
+                    if (options.headers) {
+                        options.headers['cookie'] = cookieVal;
+                    }
+                }
                 const isRateLimited = res.statusCode === 429 ||
                     chunk.includes('Error 429') ||
                     chunk.includes('Too Many Requests');
-                if (isRateLimited) {
-                    if (hasSetCookie) {
-                        cookieVal = res.headers['set-cookie'][0].split(';')[0];
-                        options.headers['cookie'] = cookieVal;
+                const isUnauthorized = res.statusCode === 401;
+                const isMovedPermanentlyOrRedirect = res.statusCode === 302;
+                if (isMovedPermanentlyOrRedirect) {
+                    cookieVal = undefined;
+                    if (options.headers) {
+                        delete options.headers['cookie'];
                     }
+                    if (attempt < MAX_RETRIES) {
+                        const retryResponse = await runRequest(options, body, attempt + 1);
+                        resolve(retryResponse);
+                        return;
+                    }
+                }
+                if (isRateLimited || isUnauthorized) {
                     if (attempt < MAX_RETRIES) {
                         const delay = BASE_DELAY_MS * Math.pow(2, attempt) + Math.floor(Math.random() * 250);
                         await sleep(delay);

package/dist/cjs/helpers/session-manager.d.ts

@@ -0,0 +1,36 @@
+export interface CookieJar {
+    NID?: string;
+    AEC?: string;
+    __Secure_BUCKET?: string;
+    OTZ?: string;
+    _ga?: string;
+    _gid?: string;
+    __utma?: string;
+    __utmz?: string;
+    [key: string]: string | undefined;
+}
+export interface SessionConfig {
+    autoRefresh?: boolean;
+    maxRetries?: number;
+    baseDelayMs?: number;
+    cookieRefreshInterval?: number;
+    initialCookies?: CookieJar | string;
+}
+export declare class SessionManager {
+    private cookies;
+    private lastRefresh;
+    private config;
+    private userAgents;
+    constructor(config?: SessionConfig);
+    initialize(): Promise<void>;
+    private parseCookieString;
+    private refreshSession;
+    private fetchCookies;
+    private parseCookies;
+    private serializeCookies;
+    private getRandomUserAgent;
+    getCookieHeader(): Promise<string>;
+    getRequestHeaders(): Record<string, string>;
+    updateFromSetCookie(setCookieHeaders: string[]): void;
+    getCookies(): CookieJar;
+}

package/dist/cjs/helpers/session-manager.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const https_1 = __importDefault(require("https"));
+const url_1 = require("url");
+class SessionManager {
+    constructor(config = {}) {
+        this.cookies = {};
+        this.lastRefresh = 0;
+        this.userAgents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15'
+        ];
+        this.config = {
+            autoRefresh: config.autoRefresh ?? true,
+            maxRetries: config.maxRetries ?? 3,
+            baseDelayMs: config.baseDelayMs ?? 750,
+            cookieRefreshInterval: config.cookieRefreshInterval ?? 30 * 60 * 1000 // 30 min
+        };
+        if (config.initialCookies) {
+            if (typeof config.initialCookies === 'string') {
+                this.cookies = this.parseCookieString(config.initialCookies);
+            }
+            else {
+                this.cookies = config.initialCookies;
+            }
+        }
+    }
+    async initialize() {
+        // If we already have essential cookies (like NID) provided manually, 
+        // we can skip the initial fetch if desired, or verify them. 
+        // For now, we'll only fetch if we don't have them or if autoRefresh implies we should.
+        if (Object.keys(this.cookies).length === 0) {
+            await this.refreshSession();
+        }
+    }
+    parseCookieString(cookieStr) {
+        const cookies = {};
+        if (!cookieStr)
+            return cookies;
+        cookieStr.split(';').forEach(pair => {
+            const [key, value] = pair.split('=');
+            if (key && value) {
+                cookies[key.trim()] = value.trim();
+            }
+        });
+        return cookies;
+    }
+    async refreshSession() {
+        try {
+            // Step 1: Hit main trends page to get initial cookies
+            const mainCookies = await this.fetchCookies('https://trends.google.com/trends/');
+            // Step 2: Hit explore page to get additional auth cookies
+            const exploreCookies = await this.fetchCookies('https://trends.google.com/trends/explore?geo=US&q=test', mainCookies);
+            this.cookies = { ...this.cookies, ...mainCookies, ...exploreCookies };
+            this.lastRefresh = Date.now();
+            // console.log('[SessionManager] Session refreshed. Cookies:', Object.keys(this.cookies));
+        }
+        catch (error) {
+            console.error('[SessionManager] Failed to refresh session:', error);
+            // Don't throw if we have fallback cookies, otherwise propagate
+            if (Object.keys(this.cookies).length === 0) {
+                throw error;
+            }
+        }
+    }
+    fetchCookies(url, existingCookies) {
+        return new Promise((resolve, reject) => {
+            const parsedUrl = new url_1.URL(url);
+            const options = {
+                hostname: parsedUrl.hostname,
+                path: parsedUrl.pathname + parsedUrl.search,
+                method: 'GET',
+                headers: {
+                    'User-Agent': this.getRandomUserAgent(),
+                    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                    'Accept-Language': 'en-US,en;q=0.9',
+                    'Accept-Encoding': 'gzip, deflate, br',
+                    'Connection': 'keep-alive',
+                    'Upgrade-Insecure-Requests': '1',
+                    'Sec-Fetch-Dest': 'document',
+                    'Sec-Fetch-Mode': 'navigate',
+                    'Sec-Fetch-Site': 'none',
+                    ...(existingCookies ? { Cookie: this.serializeCookies(existingCookies) } : {})
+                }
+            };
+            const req = https_1.default.request(options, (res) => {
+                const cookies = this.parseCookies(res.headers['set-cookie'] || []);
+                // Consume response body to free up memory/socket
+                res.on('data', () => { });
+                res.on('end', () => resolve(cookies));
+            });
+            req.on('error', reject);
+            req.setTimeout(10000, () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.end();
+        });
+    }
+    parseCookies(setCookieHeaders) {
+        const cookies = {};
+        for (const header of setCookieHeaders) {
+            const [cookiePart] = header.split(';');
+            const [key, value] = cookiePart.split('=');
+            const normalizedKey = key.replace(/__Secure-/g, '__Secure_');
+            // We accept more than just specific keys to be robust, but we can filter if needed.
+            // Keeping the filter for now to avoid junk.
+            if (['NID', 'AEC', '__Secure_BUCKET', 'OTZ', '_ga', '_gid', '__utma', '__utmz'].includes(normalizedKey)) {
+                cookies[normalizedKey] = value;
+            }
+        }
+        return cookies;
+    }
+    serializeCookies(cookies) {
+        return Object.entries(cookies)
+            .filter(([_, v]) => v !== undefined)
+            .map(([k, v]) => {
+            // Convert back to __Secure- format for sending
+            const key = k.replace(/__Secure_/g, '__Secure-');
+            return `${key}=${v}`;
+        })
+            .join('; ');
+    }
+    getRandomUserAgent() {
+        return this.userAgents[Math.floor(Math.random() * this.userAgents.length)];
+    }
+    async getCookieHeader() {
+        // Auto-refresh if needed
+        if (this.config.autoRefresh) {
+            const timeSinceRefresh = Date.now() - this.lastRefresh;
+            if (this.lastRefresh > 0 && timeSinceRefresh > this.config.cookieRefreshInterval) {
+                // console.log('[SessionManager] Auto-refreshing session...');
+                await this.refreshSession(); // Background refresh? No, await to ensure valid session.
+            }
+        }
+        return this.serializeCookies(this.cookies);
+    }
+    getRequestHeaders() {
+        return {
+            'User-Agent': this.getRandomUserAgent(),
+            'Accept': 'application/json, text/plain, */*',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Referer': 'https://trends.google.com/',
+            'Origin': 'https://trends.google.com',
+            'Connection': 'keep-alive',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Cache-Control': 'no-cache',
+            'Pragma': 'no-cache'
+        };
+    }
+    // Manual cookie update from 429 responses
+    updateFromSetCookie(setCookieHeaders) {
+        const newCookies = this.parseCookies(setCookieHeaders);
+        this.cookies = { ...this.cookies, ...newCookies };
+        // console.log('[SessionManager] Updated cookies from response');
+    }
+    // For testing/debugging
+    getCookies() {
+        return { ...this.cookies };
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/cjs/index.d.ts

@@ -6,8 +6,8 @@ export declare const explore: ({ keyword, geo, time, category, property, hl, ena
     error: import("./types/index.js").GoogleTrendsError;
 }>;
 export declare const interestByRegion: ({ keyword, startTime, endTime, geo, resolution, hl, timezone, category, enableBackoff }: import("./types/index.js").InterestByRegionOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").InterestByRegionResponse>>;
-export declare const relatedTopics: ({ keyword, geo, time, category, property, hl, enableBackoff, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
-export declare const relatedQueries: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
+export declare const relatedTopics: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedTopicsOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
+export declare const relatedQueries: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedQueriesOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
 export declare const relatedData: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedData>>;
 export { GoogleTrendsApi };
 declare const _default: {
@@ -18,8 +18,8 @@ declare const _default: {
         error: import("./types/index.js").GoogleTrendsError;
     }>;
     interestByRegion: ({ keyword, startTime, endTime, geo, resolution, hl, timezone, category, enableBackoff }: import("./types/index.js").InterestByRegionOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").InterestByRegionResponse>>;
-    relatedTopics: ({ keyword, geo, time, category, property, hl, enableBackoff, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
-    relatedQueries: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
+    relatedTopics: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedTopicsOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
+    relatedQueries: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedQueriesOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
     relatedData: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedData>>;
 };
 export default _default;

package/dist/esm/constants.js

@@ -34,17 +34,17 @@ export const GOOGLE_TRENDS_MAPPER = {
         headers: {},
     },
     [GoogleTrendsEndpoints.relatedTopics]: {
-        path: '/trends/api/widgetdata/relatedtopics',
+        path: '/trends/api/widgetdata/relatedsearches',
         method: 'GET',
         host: GOOGLE_TRENDS_BASE_URL,
-        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedtopics`,
+        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedsearches`,
         headers: {},
     },
     [GoogleTrendsEndpoints.relatedQueries]: {
-        path: '/trends/api/widgetdata/relatedqueries',
+        path: '/trends/api/widgetdata/relatedsearches',
         method: 'GET',
         host: GOOGLE_TRENDS_BASE_URL,
-        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedqueries`,
+        url: `https://${GOOGLE_TRENDS_BASE_URL}/trends/api/widgetdata/relatedsearches`,
         headers: {},
     },
 };

package/dist/esm/helpers/googleTrendsAPI.d.ts

@@ -1,4 +1,4 @@
-import { DailyTrendingTopics, DailyTrendingTopicsOptions, RealTimeTrendsOptions, ExploreOptions, ExploreResponse, InterestByRegionOptions, InterestByRegionResponse, GoogleTrendsResponse, GoogleTrendsError, RelatedTopicsResponse, RelatedQueriesResponse, RelatedData } from '../types/index.js';
+import { DailyTrendingTopics, DailyTrendingTopicsOptions, RealTimeTrendsOptions, ExploreOptions, ExploreResponse, InterestByRegionOptions, InterestByRegionResponse, GoogleTrendsResponse, GoogleTrendsError, RelatedTopicsResponse, RelatedTopicsOptions, RelatedQueriesResponse, RelatedData, RelatedQueriesOptions } from '../types/index.js';
 export declare class GoogleTrendsApi {
     /**
      * Get autocomplete suggestions for a keyword
@@ -23,8 +23,8 @@ export declare class GoogleTrendsApi {
         error: GoogleTrendsError;
     }>;
     interestByRegion({ keyword, startTime, endTime, geo, resolution, hl, timezone, category, enableBackoff }: InterestByRegionOptions): Promise<GoogleTrendsResponse<InterestByRegionResponse>>;
-    relatedTopics({ keyword, geo, time, category, property, hl, enableBackoff, }: ExploreOptions): Promise<GoogleTrendsResponse<RelatedTopicsResponse>>;
-    relatedQueries({ keyword, geo, time, category, property, hl, }: ExploreOptions): Promise<GoogleTrendsResponse<RelatedQueriesResponse>>;
+    relatedTopics({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: RelatedTopicsOptions): Promise<GoogleTrendsResponse<RelatedTopicsResponse>>;
+    relatedQueries({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: RelatedQueriesOptions): Promise<GoogleTrendsResponse<RelatedQueriesResponse>>;
     relatedData({ keyword, geo, time, category, property, hl, }: ExploreOptions): Promise<GoogleTrendsResponse<RelatedData>>;
 }
 declare const _default: GoogleTrendsApi;

package/dist/esm/helpers/googleTrendsAPI.js

@@ -204,19 +204,21 @@ export class GoogleTrendsApi {
             return { error: new UnknownError('Interest by region request failed') };
         }
     }
-    async relatedTopics({ keyword, geo = 'US', time = 'now 1-d', category = 0, property = '', hl = 'en-US', enableBackoff = false, }) {
+    async relatedTopics({ keyword, geo = 'US', startTime = new Date('2004-01-01'), endTime = new Date(), category = 0, property = '', hl = 'en-US', enableBackoff = false, }) {
         try {
             // Validate keyword
             if (!keyword || keyword.trim() === '') {
                 return { error: new InvalidRequestError('Keyword is required') };
             }
+            const keywordValue = Array.isArray(keyword) ? keyword[0] : keyword;
+            const geoValue = Array.isArray(geo) ? geo[0] : geo;
             // Step 1: Call explore to get widget data and token
+            const timeValue = `${formatDate(startTime)} ${formatDate(endTime)}`;
             const exploreResponse = await this.explore({
-                keyword,
-                geo,
-                time,
+                keyword: keywordValue,
+                geo: geoValue,
+                time: timeValue,
                 category,
-                property,
                 hl,
                 enableBackoff
             });
@@ -232,40 +234,16 @@ export class GoogleTrendsApi {
             if (!relatedTopicsWidget) {
                 return { error: new ParseError('No related topics widget found in explore response') };
             }
+            const requestFromWidget = {
+                ...relatedTopicsWidget.request
+            };
             // Step 3: Call the related topics API with or without token
             const options = {
                 ...GOOGLE_TRENDS_MAPPER[GoogleTrendsEndpoints.relatedTopics],
                 qs: {
                     hl,
                     tz: '240',
-                    req: JSON.stringify({
-                        restriction: {
-                            geo: { country: geo },
-                            time: time,
-                            originalTimeRangeForExploreUrl: time,
-                            complexKeywordsRestriction: {
-                                keyword: [{
-                                        type: 'BROAD',
-                                        value: keyword
-                                    }]
-                            }
-                        },
-                        keywordType: 'ENTITY',
-                        metric: ['TOP', 'RISING'],
-                        trendinessSettings: {
-                            compareTime: time
-                        },
-                        requestOptions: {
-                            property: property,
-                            backend: 'CM',
-                            category: category
-                        },
-                        language: hl.split('-')[0],
-                        userCountryCode: geo,
-                        userConfig: {
-                            userType: 'USER_TYPE_LEGIT_USER'
-                        }
-                    }),
+                    req: JSON.stringify(requestFromWidget),
                     ...(relatedTopicsWidget.token && { token: relatedTopicsWidget.token })
                 }
             };
@@ -276,11 +254,7 @@ export class GoogleTrendsApi {
                 const data = JSON.parse(text.slice(5));
                 // Return the data in the expected format
                 return {
-                    data: {
-                        default: {
-                            rankedList: data.default?.rankedList || []
-                        }
-                    }
+                    data: data.default?.rankedList || []
                 };
             }
             catch (parseError) {
@@ -297,32 +271,62 @@ export class GoogleTrendsApi {
             return { error: new UnknownError() };
         }
     }
-    async relatedQueries({ keyword, geo = 'US', time = 'now 1-d', category = 0, property = '', hl = 'en-US', }) {
+    async relatedQueries({ keyword, geo = 'US', startTime = new Date('2004-01-01'), endTime = new Date(), category = 0, property = '', hl = 'en-US', enableBackoff = false, }) {
         try {
             // Validate keyword
             if (!keyword || keyword.trim() === '') {
-                return { error: new ParseError() };
+                return { error: new InvalidRequestError('Keyword is required') };
             }
-            const autocompleteResult = await this.autocomplete(keyword, hl);
-            if (autocompleteResult.error) {
-                return { error: autocompleteResult.error };
+            const keywordValue = Array.isArray(keyword) ? keyword[0] : keyword;
+            const geoValue = Array.isArray(geo) ? geo[0] : geo;
+            // Step 1: Call explore to get widget data and token
+            const timeValue = `${formatDate(startTime)} ${formatDate(endTime)}`;
+            const exploreResponse = await this.explore({
+                keyword: keywordValue,
+                geo: geoValue,
+                time: timeValue,
+                category,
+                hl,
+                enableBackoff
+            });
+            if ('error' in exploreResponse) {
+                return { error: exploreResponse.error };
             }
-            const relatedQueries = autocompleteResult.data?.slice(0, 10).map((suggestion, index) => ({
-                query: suggestion,
-                value: 100 - index * 10,
-                formattedValue: (100 - index * 10).toString(),
-                hasData: true,
-                link: `/trends/explore?q=${encodeURIComponent(suggestion)}&date=${time}&geo=${geo}`
-            })) || [];
-            return {
-                data: {
-                    default: {
-                        rankedList: [{
-                                rankedKeyword: relatedQueries
-                            }]
-                    }
+            if (!exploreResponse.widgets || exploreResponse.widgets.length === 0) {
+                return { error: new ParseError('No widgets found in explore response. This might be due to Google blocking the request, invalid parameters, or network issues.') };
+            }
+            const relatedQueriesWidget = exploreResponse.widgets.find(widget => widget.id === 'RELATED_QUERIES') || null; // Fallback to first widget if no specific one found
+            if (!relatedQueriesWidget) {
+                return { error: new ParseError('No related queries widget found in explore response') };
+            }
+            const requestFromWidget = {
+                ...relatedQueriesWidget.request
+            };
+            const options = {
+                ...GOOGLE_TRENDS_MAPPER[GoogleTrendsEndpoints.relatedQueries],
+                qs: {
+                    hl,
+                    tz: '240',
+                    req: JSON.stringify(requestFromWidget),
+                    token: relatedQueriesWidget.token
                 }
             };
+            const response = await request(options.url, options, enableBackoff);
+            const text = await response.text();
+            // Parse the response
+            try {
+                const data = JSON.parse(text.slice(5));
+                // Return the data in the expected format
+                return {
+                    data: data.default?.rankedList || []
+                };
+            }
+            catch (parseError) {
+                if (parseError instanceof Error) {
+                    return { error: new ParseError(`Failed to parse related queries response: ${parseError.message}`) };
+                }
+                return { error: new ParseError('Failed to parse related queries response') };
+            }
         }
         catch (error) {
             if (error instanceof Error) {

package/dist/esm/helpers/request.js

@@ -11,14 +11,31 @@ async function runRequest(options, body, attempt) {
             res.on('data', (data) => { chunk += data; });
             res.on('end', async () => {
                 const hasSetCookie = !!res.headers['set-cookie']?.length;
+                if (hasSetCookie) {
+                    // Only keep the name=value part of the cookie, discard attributes like Expires, Path, etc.
+                    const newCookie = res.headers['set-cookie'][0].split(';')[0];
+                    cookieVal = newCookie;
+                    if (options.headers) {
+                        options.headers['cookie'] = cookieVal;
+                    }
+                }
                 const isRateLimited = res.statusCode === 429 ||
                     chunk.includes('Error 429') ||
                     chunk.includes('Too Many Requests');
-                if (isRateLimited) {
-                    if (hasSetCookie) {
-                        cookieVal = res.headers['set-cookie'][0].split(';')[0];
-                        options.headers['cookie'] = cookieVal;
+                const isUnauthorized = res.statusCode === 401;
+                const isMovedPermanentlyOrRedirect = res.statusCode === 302;
+                if (isMovedPermanentlyOrRedirect) {
+                    cookieVal = undefined;
+                    if (options.headers) {
+                        delete options.headers['cookie'];
                     }
+                    if (attempt < MAX_RETRIES) {
+                        const retryResponse = await runRequest(options, body, attempt + 1);
+                        resolve(retryResponse);
+                        return;
+                    }
+                }
+                if (isRateLimited || isUnauthorized) {
                     if (attempt < MAX_RETRIES) {
                         const delay = BASE_DELAY_MS * Math.pow(2, attempt) + Math.floor(Math.random() * 250);
                         await sleep(delay);

package/dist/esm/helpers/session-manager.d.ts

@@ -0,0 +1,36 @@
+export interface CookieJar {
+    NID?: string;
+    AEC?: string;
+    __Secure_BUCKET?: string;
+    OTZ?: string;
+    _ga?: string;
+    _gid?: string;
+    __utma?: string;
+    __utmz?: string;
+    [key: string]: string | undefined;
+}
+export interface SessionConfig {
+    autoRefresh?: boolean;
+    maxRetries?: number;
+    baseDelayMs?: number;
+    cookieRefreshInterval?: number;
+    initialCookies?: CookieJar | string;
+}
+export declare class SessionManager {
+    private cookies;
+    private lastRefresh;
+    private config;
+    private userAgents;
+    constructor(config?: SessionConfig);
+    initialize(): Promise<void>;
+    private parseCookieString;
+    private refreshSession;
+    private fetchCookies;
+    private parseCookies;
+    private serializeCookies;
+    private getRandomUserAgent;
+    getCookieHeader(): Promise<string>;
+    getRequestHeaders(): Record<string, string>;
+    updateFromSetCookie(setCookieHeaders: string[]): void;
+    getCookies(): CookieJar;
+}

package/dist/esm/helpers/session-manager.js

@@ -0,0 +1,165 @@
+import https from 'https';
+import { URL } from 'url';
+export class SessionManager {
+    constructor(config = {}) {
+        this.cookies = {};
+        this.lastRefresh = 0;
+        this.userAgents = [
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
+            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15'
+        ];
+        this.config = {
+            autoRefresh: config.autoRefresh ?? true,
+            maxRetries: config.maxRetries ?? 3,
+            baseDelayMs: config.baseDelayMs ?? 750,
+            cookieRefreshInterval: config.cookieRefreshInterval ?? 30 * 60 * 1000 // 30 min
+        };
+        if (config.initialCookies) {
+            if (typeof config.initialCookies === 'string') {
+                this.cookies = this.parseCookieString(config.initialCookies);
+            }
+            else {
+                this.cookies = config.initialCookies;
+            }
+        }
+    }
+    async initialize() {
+        // If we already have essential cookies (like NID) provided manually, 
+        // we can skip the initial fetch if desired, or verify them. 
+        // For now, we'll only fetch if we don't have them or if autoRefresh implies we should.
+        if (Object.keys(this.cookies).length === 0) {
+            await this.refreshSession();
+        }
+    }
+    parseCookieString(cookieStr) {
+        const cookies = {};
+        if (!cookieStr)
+            return cookies;
+        cookieStr.split(';').forEach(pair => {
+            const [key, value] = pair.split('=');
+            if (key && value) {
+                cookies[key.trim()] = value.trim();
+            }
+        });
+        return cookies;
+    }
+    async refreshSession() {
+        try {
+            // Step 1: Hit main trends page to get initial cookies
+            const mainCookies = await this.fetchCookies('https://trends.google.com/trends/');
+            // Step 2: Hit explore page to get additional auth cookies
+            const exploreCookies = await this.fetchCookies('https://trends.google.com/trends/explore?geo=US&q=test', mainCookies);
+            this.cookies = { ...this.cookies, ...mainCookies, ...exploreCookies };
+            this.lastRefresh = Date.now();
+            // console.log('[SessionManager] Session refreshed. Cookies:', Object.keys(this.cookies));
+        }
+        catch (error) {
+            console.error('[SessionManager] Failed to refresh session:', error);
+            // Don't throw if we have fallback cookies, otherwise propagate
+            if (Object.keys(this.cookies).length === 0) {
+                throw error;
+            }
+        }
+    }
+    fetchCookies(url, existingCookies) {
+        return new Promise((resolve, reject) => {
+            const parsedUrl = new URL(url);
+            const options = {
+                hostname: parsedUrl.hostname,
+                path: parsedUrl.pathname + parsedUrl.search,
+                method: 'GET',
+                headers: {
+                    'User-Agent': this.getRandomUserAgent(),
+                    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
+                    'Accept-Language': 'en-US,en;q=0.9',
+                    'Accept-Encoding': 'gzip, deflate, br',
+                    'Connection': 'keep-alive',
+                    'Upgrade-Insecure-Requests': '1',
+                    'Sec-Fetch-Dest': 'document',
+                    'Sec-Fetch-Mode': 'navigate',
+                    'Sec-Fetch-Site': 'none',
+                    ...(existingCookies ? { Cookie: this.serializeCookies(existingCookies) } : {})
+                }
+            };
+            const req = https.request(options, (res) => {
+                const cookies = this.parseCookies(res.headers['set-cookie'] || []);
+                // Consume response body to free up memory/socket
+                res.on('data', () => { });
+                res.on('end', () => resolve(cookies));
+            });
+            req.on('error', reject);
+            req.setTimeout(10000, () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+            req.end();
+        });
+    }
+    parseCookies(setCookieHeaders) {
+        const cookies = {};
+        for (const header of setCookieHeaders) {
+            const [cookiePart] = header.split(';');
+            const [key, value] = cookiePart.split('=');
+            const normalizedKey = key.replace(/__Secure-/g, '__Secure_');
+            // We accept more than just specific keys to be robust, but we can filter if needed.
+            // Keeping the filter for now to avoid junk.
+            if (['NID', 'AEC', '__Secure_BUCKET', 'OTZ', '_ga', '_gid', '__utma', '__utmz'].includes(normalizedKey)) {
+                cookies[normalizedKey] = value;
+            }
+        }
+        return cookies;
+    }
+    serializeCookies(cookies) {
+        return Object.entries(cookies)
+            .filter(([_, v]) => v !== undefined)
+            .map(([k, v]) => {
+            // Convert back to __Secure- format for sending
+            const key = k.replace(/__Secure_/g, '__Secure-');
+            return `${key}=${v}`;
+        })
+            .join('; ');
+    }
+    getRandomUserAgent() {
+        return this.userAgents[Math.floor(Math.random() * this.userAgents.length)];
+    }
+    async getCookieHeader() {
+        // Auto-refresh if needed
+        if (this.config.autoRefresh) {
+            const timeSinceRefresh = Date.now() - this.lastRefresh;
+            if (this.lastRefresh > 0 && timeSinceRefresh > this.config.cookieRefreshInterval) {
+                // console.log('[SessionManager] Auto-refreshing session...');
+                await this.refreshSession(); // Background refresh? No, await to ensure valid session.
+            }
+        }
+        return this.serializeCookies(this.cookies);
+    }
+    getRequestHeaders() {
+        return {
+            'User-Agent': this.getRandomUserAgent(),
+            'Accept': 'application/json, text/plain, */*',
+            'Accept-Language': 'en-US,en;q=0.9',
+            'Accept-Encoding': 'gzip, deflate, br',
+            'Referer': 'https://trends.google.com/',
+            'Origin': 'https://trends.google.com',
+            'Connection': 'keep-alive',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'same-origin',
+            'Cache-Control': 'no-cache',
+            'Pragma': 'no-cache'
+        };
+    }
+    // Manual cookie update from 429 responses
+    updateFromSetCookie(setCookieHeaders) {
+        const newCookies = this.parseCookies(setCookieHeaders);
+        this.cookies = { ...this.cookies, ...newCookies };
+        // console.log('[SessionManager] Updated cookies from response');
+    }
+    // For testing/debugging
+    getCookies() {
+        return { ...this.cookies };
+    }
+}

package/dist/esm/index.d.ts

@@ -6,8 +6,8 @@ export declare const explore: ({ keyword, geo, time, category, property, hl, ena
     error: import("./types/index.js").GoogleTrendsError;
 }>;
 export declare const interestByRegion: ({ keyword, startTime, endTime, geo, resolution, hl, timezone, category, enableBackoff }: import("./types/index.js").InterestByRegionOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").InterestByRegionResponse>>;
-export declare const relatedTopics: ({ keyword, geo, time, category, property, hl, enableBackoff, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
-export declare const relatedQueries: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
+export declare const relatedTopics: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedTopicsOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
+export declare const relatedQueries: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedQueriesOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
 export declare const relatedData: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedData>>;
 export { GoogleTrendsApi };
 declare const _default: {
@@ -18,8 +18,8 @@ declare const _default: {
         error: import("./types/index.js").GoogleTrendsError;
     }>;
     interestByRegion: ({ keyword, startTime, endTime, geo, resolution, hl, timezone, category, enableBackoff }: import("./types/index.js").InterestByRegionOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").InterestByRegionResponse>>;
-    relatedTopics: ({ keyword, geo, time, category, property, hl, enableBackoff, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
-    relatedQueries: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
+    relatedTopics: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedTopicsOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedTopicsResponse>>;
+    relatedQueries: ({ keyword, geo, startTime, endTime, category, property, hl, enableBackoff, }: import("./types/index.js").RelatedQueriesOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedQueriesResponse>>;
     relatedData: ({ keyword, geo, time, category, property, hl, }: import("./types/index.js").ExploreOptions) => Promise<import("./types/index.js").GoogleTrendsResponse<import("./types/index.js").RelatedData>>;
 };
 export default _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaivpidadi/trends-js",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Google Trends API for Node.js",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",