patch_profile_proxy_many_v2
Update proxies for multiple browser profiles in GoLogin by specifying profile IDs and proxy configurations. Streamline profile management with HTTP, SOCKS, or other supported proxy modes.
Instructions
Update proxy for multiple profiles
Input Schema
| Name | Required | Description | Default |
|---|---|---|---|
| proxies | Yes | List of profiles with their proxies. |
Input Schema (JSON Schema)
{
"properties": {
"proxies": {
"description": "List of profiles with their proxies.",
"items": {
"properties": {
"profileId": {
"description": "Profile ID to update.",
"type": "string"
},
"proxy": {
"description": "Proxy parameters that you want to update.",
"properties": {
"changeIpUrl": {
"description": "This allows you to change IP address of the proxy if your proxy provider supports it.",
"type": "string"
},
"customName": {
"description": "As proxy is separate entity in gologin, you can set custom name for it to identify it in the list of proxies.",
"type": "string"
},
"host": {
"description": "Proxy host. It could be ip address or domain name.",
"type": "string"
},
"id": {
"description": "You can specify particular proxy by its id or leave it empty to use default proxy.",
"type": "string"
},
"mode": {
"description": "Proxy mode represent the protocolo of the connection to the proxy.",
"enum": [
"http",
"socks4",
"socks5",
"possh",
"geolocation",
"none",
"gologin",
"tor"
],
"type": "string"
},
"password": {
"description": "Proxy password if proxy requires authentication.",
"type": "string"
},
"port": {
"description": "Proxy port.",
"type": "number"
},
"username": {
"description": "Proxy username.",
"type": "string"
}
},
"required": [
"mode"
],
"type": "object"
}
},
"required": [
"profileId",
"proxy"
],
"type": "object"
},
"type": "array"
}
},
"required": [
"proxies"
],
"type": "object"
}
Implementation Reference
- src/index.ts:454-570 (handler)Dynamic handler that executes the 'patch_profile_proxy_many_v2' tool by resolving the tool name to the matching OpenAPI PATCH operation on the profile proxy many v2 path, parsing arguments into path/query/body params, constructing the request URL, adding auth if token provided, and performing the fetch to the GoLogin API base URL.private async callDynamicTool( toolName: string, parameters: CallParameters = {}, headers: Record<string, string> = {} ): Promise<CallToolResult> { console.log('parameters', parameters.body); if (!this.apiSpec || !this.apiSpec.paths) { throw new Error('API specification not loaded'); } let targetPath = ''; let targetMethod = ''; let operation: OpenAPIV3.OperationObject | undefined; for (const [path, pathItem] of Object.entries(this.apiSpec.paths)) { if (!pathItem) continue; for (const [method, op] of Object.entries(pathItem)) { if (['get', 'post', 'put', 'delete', 'patch', 'head', 'options'].includes(method) && op) { const opObj = op as OpenAPIV3.OperationObject; const generatedToolName = `${method}${path.replace('browser', 'profile').replace(/[^a-zA-Z0-9]/g, '_')}`; if (generatedToolName === toolName) { targetPath = path; targetMethod = method.toUpperCase(); operation = opObj; break; } } } if (operation) break; } if (!operation) { throw new Error(`Tool "${toolName}" not found`); } let url = `${this.baseUrl}${targetPath}`; const requestHeaders: Record<string, string> = { ...headers }; let requestBody: string | undefined; requestHeaders['User-Agent'] = 'gologin-mcp'; console.error('this.token', this.token); if (this.token) { requestHeaders['Authorization'] = `Bearer ${this.token}`; } if (parameters.path) { for (const [key, value] of Object.entries(parameters.path)) { url = url.replace(`{${key}}`, encodeURIComponent(value)); } } const queryParams = new URLSearchParams(); if (parameters.query) { for (const [key, value] of Object.entries(parameters.query)) { if (value) { queryParams.append(key, value); } } } if (queryParams.toString()) { url += `?${queryParams.toString()}`; } if (parameters.body && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(targetMethod)) { requestHeaders['Content-Type'] = 'application/json'; requestBody = JSON.stringify(parameters.body); } console.log('requestBody', requestBody); try { const fetchOptions: RequestInit = { method: targetMethod, headers: requestHeaders, }; console.error('fetchOptions', fetchOptions); if (requestBody) { fetchOptions.body = requestBody; } const response = await fetch(url, fetchOptions); const responseHeaders: Record<string, string> = {}; response.headers.forEach((value, key) => { responseHeaders[key] = value; }); let responseBody: any; const contentType = response.headers.get('content-type') || ''; if (contentType.includes('application/json')) { try { responseBody = await response.json(); } catch { responseBody = await response.text(); } } else { responseBody = await response.text(); } return { content: [ { type: 'text', text: `API Call Result:\n` + `URL: ${url}\n` + `Method: ${targetMethod}\n` + `Status: ${response.status} ${response.statusText}\n\n` + `Response Headers:\n${JSON.stringify(responseHeaders, null, 2)}\n\n` + `Response Body:\n${typeof responseBody === 'object' ? JSON.stringify(responseBody, null, 2) : responseBody}`, }, ], }; } catch (error) { throw new Error(`API call failed: ${error instanceof Error ? error.message : String(error)}`); } }
- src/index.ts:47-71 (registration)Tool registration via dynamic generation in ListToolsRequestHandler: iterates OpenAPI paths, generates tool names using `${method}${path.replace('browser','profile').replace(/[^a-zA-Z0-9]/g, '_')}`, including 'patch_profile_proxy_many_v2' for the corresponding PATCH /profile...proxy/many/v2 endpoint, and provides inputSchema.this.server.setRequestHandler(ListToolsRequestSchema, async () => { const tools: Tool[] = []; if (this.apiSpec && this.apiSpec.paths) { for (const [path, pathItem] of Object.entries(this.apiSpec.paths)) { if (!pathItem) continue; for (const [method, operation] of Object.entries(pathItem)) { if (['get', 'post', 'put', 'delete', 'patch', 'head', 'options'].includes(method) && operation) { const op = operation as OpenAPIV3.OperationObject; const toolName = `${method}${path.replace('browser', 'profile').replace(/[^a-zA-Z0-9]/g, '_')}`; const inputSchema = this.buildInputSchema(op, path); tools.push({ name: toolName, description: op.summary || op.description || `${method.toUpperCase()} ${path}`, inputSchema, }); } } } } return { tools }; });
- src/index.ts:204-249 (schema)Dynamically builds JSON schema for tool inputs by combining path parameters (including {id} etc.), query parameters, and requestBody schema from OpenAPI, converted from OpenAPI SchemaObjects, handling allOf, refs, enums etc., used for 'patch_profile_proxy_many_v2'.private buildInputSchema(operation: OpenAPIV3.OperationObject, path: string): any { const properties: any = {}; const required: string[] = []; const pathParams = this.extractPathParameters(operation, path); const queryParams = this.extractQueryParameters(operation); const bodySchema = this.extractRequestBodySchema(operation); if (pathParams.properties && Object.keys(pathParams.properties).length > 0) { for (const [key, prop] of Object.entries(pathParams.properties)) { properties[key] = this.convertOpenAPISchemaToJsonSchema(prop as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject); if (pathParams.required.includes(key)) { required.push(key); } } } if (queryParams.properties && Object.keys(queryParams.properties).length > 0) { for (const [key, prop] of Object.entries(queryParams.properties)) { properties[key] = this.convertOpenAPISchemaToJsonSchema(prop as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject); if (queryParams.required.includes(key)) { required.push(key); } } } if (bodySchema && bodySchema.properties) { for (const [key, prop] of Object.entries(bodySchema.properties)) { properties[key] = this.convertOpenAPISchemaToJsonSchema(prop as OpenAPIV3.SchemaObject | OpenAPIV3.ReferenceObject); if (bodySchema.required && bodySchema.required.includes(key)) { required.push(key); } } } const schema: any = { type: 'object', properties, }; if (required.length > 0) { schema.required = required; } return schema; }
- src/index.ts:96-175 (helper)Helper to parse tool arguments into structured CallParameters (path, query, body) by matching against OpenAPI operation parameters and path placeholders for the specific tool.private extractParametersFromArgs(toolName: string, args: Record<string, any>): CallParameters { if (!this.apiSpec || !this.apiSpec.paths) { return { body: args }; } let operation: OpenAPIV3.OperationObject | undefined; let path = ''; for (const [apiPath, pathItem] of Object.entries(this.apiSpec.paths)) { if (!pathItem) continue; for (const [method, op] of Object.entries(pathItem)) { if (['get', 'post', 'put', 'delete', 'patch', 'head', 'options'].includes(method) && op) { const opObj = op as OpenAPIV3.OperationObject; const generatedToolName = opObj.operationId || `${method}_${apiPath.replace(/[^a-zA-Z0-9]/g, '_')}`; if (generatedToolName === toolName) { operation = opObj; path = apiPath; break; } } } if (operation) break; } if (!operation) { return { body: args }; } const pathParams: Record<string, string> = {}; const queryParams: Record<string, string> = {}; const bodyParams: any = {}; const pathParamNames = path.match(/\{([^}]+)\}/g)?.map(p => p.slice(1, -1)) || []; if (operation.parameters) { operation.parameters.forEach(param => { if ('$ref' in param) return; const parameter = param as OpenAPIV3.ParameterObject; const paramName = parameter.name; if (parameter.in === 'path' && args[paramName] !== undefined) { pathParams[paramName] = String(args[paramName]); } else if (parameter.in === 'query' && args[paramName] !== undefined) { queryParams[paramName] = String(args[paramName]); } }); } pathParamNames.forEach(paramName => { if (args[paramName] !== undefined && !pathParams[paramName]) { pathParams[paramName] = String(args[paramName]); } }); const usedParams = new Set([...Object.keys(pathParams), ...Object.keys(queryParams)]); for (const [key, value] of Object.entries(args)) { if (!usedParams.has(key)) { bodyParams[key] = value; } } const parameters: CallParameters = {}; if (Object.keys(pathParams).length > 0) { parameters.path = pathParams; } if (Object.keys(queryParams).length > 0) { parameters.query = queryParams; } if (Object.keys(bodyParams).length > 0) { parameters.body = bodyParams; } return parameters; }
- src/index.ts:73-94 (helper)The CallToolRequestHandler wrapper that extracts name/args, calls extractParametersFromArgs, and invokes callDynamicTool for execution.this.server.setRequestHandler(CallToolRequestSchema, async (request: any): Promise<CallToolResult> => { const { name, arguments: args } = request.params; if (!args) { throw new Error('No arguments provided'); } console.log('args', args); try { const parameters: CallParameters = this.extractParametersFromArgs(name, args); return await this.callDynamicTool(name, parameters, args.headers as Record<string, string> | undefined); } catch (error) { return { content: [ { type: 'text', text: `Error: ${error instanceof Error ? error.message : String(error)}`, }, ], }; } }); }