@hyperbrowser/n8n-nodes
Version:
n8n node for Hyperbrowser - enabling web scraping, crawling, and AI-powered data extraction in your workflows
382 lines • 16.6 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Hyperbrowser = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const sdk_1 = require("@hyperbrowser/sdk");
class Hyperbrowser {
constructor() {
this.description = {
displayName: 'Hyperbrowser',
name: 'hyperbrowser',
icon: 'file:hyperbrowser.svg',
group: ['transform'],
version: 1,
description: 'Interact with websites using Hyperbrowser',
defaults: {
name: 'Hyperbrowser',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'hyperbrowserApi',
required: true,
},
],
usableAsTool: true,
properties: [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Browser Use',
value: 'browserUse',
description: 'Hyperbrowser Browser Agent using Browser-Use',
action: 'Hyperbrowser browser agent using browser use agent',
},
{
name: 'Claude Computer Use',
value: 'claudeComputerUse',
description: 'Use Claude to control computer actions',
action: 'Hyperbrowser browser agent using claude computer use',
},
{
name: 'Crawl',
value: 'crawl',
description: 'Crawl a website and its links',
action: 'Crawl a website',
},
{
name: 'Extract',
value: 'extract',
description: 'Extract specific data from a webpage using AI',
action: 'Extract data from a webpage',
},
{
name: 'OpenAI CUA',
value: 'openaiCua',
description: 'Use OpenAI to control user actions',
action: 'Hyperbrowser browser agent using open ai cua',
},
{
name: 'Scrape',
value: 'scrape',
description: 'Scrape a URL',
action: 'Scrape a URL',
},
],
default: 'scrape',
},
{
displayName: 'URL',
name: 'url',
type: 'string',
required: true,
default: '',
description: 'URL to process',
placeholder: 'https://example.com',
displayOptions: {
show: {
operation: ['scrape', 'crawl', 'extract'],
},
},
},
{
displayName: 'Extraction Query',
name: 'extractionQuery',
type: 'string',
default: '',
description: 'What data to extract from the webpage (e.g., "Extract all product prices")',
displayOptions: {
show: {
operation: ['extract'],
},
},
},
{
displayName: 'Extraction Schema',
name: 'extractionSchema',
type: 'json',
default: null,
description: 'Schema of data to extract from the page (e.g., "Extract all product prices")',
displayOptions: {
show: {
operation: ['extract'],
},
},
},
{
displayName: 'Task',
name: 'task',
type: 'string',
required: true,
default: '',
description: 'Instructions for browser automation (e.g., "Click the login button and fill in the form")',
displayOptions: {
show: {
operation: ['browserUse', 'claudeComputerUse', 'openaiCua'],
},
},
},
{
displayName: 'Options',
name: 'options',
type: 'collection',
placeholder: 'Add Option',
default: {},
options: [
{
displayName: 'Max Steps',
name: 'maxSteps',
type: 'number',
default: 25,
description: 'Maximum number of steps the agent should have to complete the task',
displayOptions: {
show: {
'/operation': ['browserUse', 'claudeComputerUse', 'openaiCua'],
},
},
},
{
displayName: 'Maximum Pages',
name: 'maxPages',
type: 'number',
default: 10,
description: 'Maximum number of pages to crawl',
displayOptions: {
show: {
'/operation': ['crawl'],
},
},
},
{
displayName: 'Only Main Content',
name: 'onlyMainContent',
type: 'boolean',
default: true,
description: 'Whether to return only the main content of the page',
displayOptions: {
show: {
'/operation': ['crawl', 'scrape'],
},
},
},
{
displayName: 'Output Format',
name: 'format',
type: 'options',
options: [
{
name: 'HTML',
value: 'html',
},
{
name: 'Links',
value: 'links',
},
{
name: 'Markdown',
value: 'markdown',
},
],
default: 'markdown',
description: 'Output format to return',
displayOptions: {
show: {
'/operation': ['scrape', 'crawl'],
},
},
},
{
displayName: 'Proxy Country',
name: 'proxyCountry',
type: 'string',
default: '',
description: 'Country for proxy server',
displayOptions: {
show: {
useProxy: [true],
},
},
},
{
displayName: 'Solve CAPTCHAs',
name: 'solveCaptchas',
type: 'boolean',
default: false,
description: 'Whether to solve CAPTCHAs during scraping',
},
{
displayName: 'Timeout (Ms)',
name: 'timeout',
type: 'number',
default: 15000,
description: 'Maximum timeout for navigating to a page in milliseconds',
},
{
displayName: 'Use Proxy',
name: 'useProxy',
type: 'boolean',
default: false,
description: 'Whether to use a proxy for scraping',
},
{
displayName: 'Use Vision',
name: 'useVision',
type: 'boolean',
default: true,
description: 'Whether to use vision for Browser Use LLM',
displayOptions: {
show: {
'/operation': ['browserUse'],
},
},
},
],
},
],
};
}
async execute() {
var _a, _b, _c, _d, _e;
const items = this.getInputData();
const returnData = [];
const credentials = await this.getCredentials('hyperbrowserApi');
const client = new sdk_1.Hyperbrowser({
apiKey: credentials.apiKey,
});
for (let i = 0; i < items.length; i++) {
try {
const operation = this.getNodeParameter('operation', i);
const options = this.getNodeParameter('options', i, {});
const sessionOptions = options.useProxy
? {
useProxy: true,
solveCaptchas: options.solveCaptchas || false,
proxyCountry: options.proxyCountry || 'US',
}
: undefined;
let responseData;
if (operation === 'scrape') {
const url = this.getNodeParameter('url', i);
const scrapeOptions = {
formats: [options.format || 'markdown'],
onlyMainContent: (_a = options.onlyMainContent) !== null && _a !== void 0 ? _a : true,
timeout: options.timeout || 15000,
};
const response = await client.scrape.startAndWait({
url,
scrapeOptions,
sessionOptions,
});
responseData = {
url,
content: response.data,
status: response.status,
};
}
else if (operation === 'crawl') {
const url = this.getNodeParameter('url', i);
const response = await client.crawl.startAndWait({
url,
maxPages: options.maxPages || 10,
scrapeOptions: {
formats: ['markdown'],
onlyMainContent: (_b = options.onlyMainContent) !== null && _b !== void 0 ? _b : true,
timeout: options.timeout || 15000,
},
sessionOptions,
});
responseData = {
url,
data: response.data,
status: response.status,
};
}
else if (operation === 'extract') {
const url = this.getNodeParameter('url', i);
const extractionQuery = this.getNodeParameter('extractionQuery', i);
const extractionSchema = this.getNodeParameter('extractionSchema', i);
const response = await client.extract.startAndWait({
urls: [url],
prompt: extractionQuery,
schema: extractionSchema ? JSON.parse(extractionSchema) : null,
sessionOptions,
});
responseData = {
url,
extractedData: response.data,
status: response.status,
};
}
else if (operation === 'browserUse') {
const browserInstructions = this.getNodeParameter('task', i);
const useVision = options.useVision;
const maxSteps = options.maxSteps;
const response = await client.agents.browserUse.startAndWait({
task: browserInstructions,
useVision,
maxSteps,
sessionOptions,
});
responseData = {
actions: (_c = response.data) === null || _c === void 0 ? void 0 : _c.finalResult,
status: response.status,
};
}
else if (operation === 'claudeComputerUse') {
const computerInstructions = this.getNodeParameter('task', i);
const maxSteps = options.maxSteps;
const response = await client.agents.claudeComputerUse.startAndWait({
task: computerInstructions,
maxSteps,
sessionOptions,
});
responseData = {
actions: (_d = response.data) === null || _d === void 0 ? void 0 : _d.finalResult,
status: response.status,
};
}
else if (operation === 'openaiCua') {
const userActionInstructions = this.getNodeParameter('task', i);
const maxSteps = options.maxSteps;
const response = await client.agents.cua.startAndWait({
task: userActionInstructions,
maxSteps,
sessionOptions,
});
responseData = {
actions: (_e = response.data) === null || _e === void 0 ? void 0 : _e.finalResult,
status: response.status,
};
}
else {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation "${operation}" is not supported`);
}
returnData.push({
json: responseData,
pairedItem: { item: i },
});
}
catch (error) {
if (this.continueOnFail()) {
returnData.push({
json: {
error: error.message,
task: this.getNodeParameter('operation', i),
},
pairedItem: { item: i },
});
continue;
}
throw error;
}
}
return [returnData];
}
}
exports.Hyperbrowser = Hyperbrowser;
//# sourceMappingURL=Hyperbrowser.node.js.map