--- name: go-rod-master-c9c7139f6490 description: "Comprehensive guide for browser automation and web scraping with go-rod (Chrome DevTools Protocol) including stealth anti-bot-detection patterns." risk: safe source: "https://github.com/go-rod/rod" date_added: "2026-02-27" --- # Go-Rod Browser Automation Master ## Overview [Rod](https://github.com/go-rod/rod) is a high-level Go driver built directly on the [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) for browser automation and web scraping. Unlike wrappers around other tools, Rod communicates with the browser natively via CDP, providing thread-safe operations, chained context design for timeouts/cancellation, auto-wait for elements, correct iframe/shadow DOM handling, and zero zombie browser processes. The companion library [go-rod/stealth](https://github.com/go-rod/stealth) injects anti-bot-detection evasions based on [puppeteer-extra stealth](https://github.com/nichochar/puppeteer-extra/tree/master/packages/extract-stealth-evasions), hiding headless browser fingerprints from detection systems. ## When to Use This Skill - Use when the user asks to **scrape**, **automate**, or **test** a website using Go. - Use when the user needs a **headless browser** for dynamic/SPA content (React, Vue, Angular). - Use when the user mentions **stealth**, **anti-bot**, **avoiding detection**, **Cloudflare**, or **bot detection bypass**. - Use when the user wants to work with the **Chrome DevTools Protocol (CDP)** directly from Go. - Use when the user needs to **intercept** or **hijack** network requests in a browser context. - Use when the user asks about **concurrent browser scraping** or **page pooling** in Go. - Use when the user is migrating from **chromedp** or **Playwright Go** and wants a simpler API. ## Safety & Risk **Risk Level: 🔵 Safe** - **Read-Only by Default:** Default behavior is navigating and reading page content (scraping/testing). - **Isolated Contexts:** Browser contexts are sandboxed; cookies and storage do not persist unless explicitly saved. - **Resource Cleanup:** Designed around Go's `defer` pattern — browsers and pages close automatically. - **No External Mutations:** Does not modify external state unless the script explicitly submits forms or POSTs data. ## Installation ```bash # Core rod library go get github.com/go-rod/rod@latest # Stealth anti-detection plugin (ALWAYS include for production scraping) go get github.com/go-rod/stealth@latest ``` Rod auto-downloads a compatible Chromium binary on first run. To pre-download: ```bash go run github.com/nichochar/go-rod.github.io/cmd/launcher@latest ``` ## Core Concepts ### Browser Lifecycle Rod manages three layers: **Browser → Page → Element**. ```go // Launch and connect to a browser browser := rod.New().MustConnect() defer browser.MustClose() // Create a page (tab) page := browser.MustPage("https://example.com") // Find an element el := page.MustElement("h1") fmt.Println(el.MustText()) ``` ### Must vs Error Patterns Rod provides two API styles for every operation: | Style | Method | Use Case | |:------|:-------|:---------| | **Must** | `MustElement()`, `MustClick()`, `MustText()` | Scripting, debugging, prototyping. Panics on error. | | **Error** | `Element()`, `Click()`, `Text()` | Production code. Returns `error` for explicit handling. | **Production pattern:** ```go el, err := page.Element("#login-btn") if err != nil { return fmt.Errorf("login button not found: %w", err) } if err := el.Click(proto.InputMouseButtonLeft, 1); err != nil { return fmt.Errorf("click failed: %w", err) } ``` **Scripting pattern with Try:** ```go err := rod.Try(func() { page.MustElement("#login-btn").MustClick() }) if errors.Is(err, context.DeadlineExceeded) { log.Println("timeout finding login button") } ``` ### Context & Timeout Rod uses Go's `context.Context` for cancellation and timeouts. Context propagates recursively to all child operations. ```go // Set a 5-second timeout for the entire operation chain page.Timeout(5 * time.Second). MustWaitLoad(). MustElement("title"). CancelTimeout(). // subsequent calls are not bound by the 5s timeout Timeout(30 * time.Second). MustText() ``` ### Element Selectors Rod supports multiple selector strategies: ```go // CSS selector (most common) page.MustElement("div.content > p.intro") // CSS selector with text regex matching page.MustElementR("button", "Submit|Send") // XPath page.MustElementX("//div[@class='content']//p") // Search across iframes and shadow DOM (like DevTools Ctrl+F) page.MustSearch(".deeply-nested-element") ``` ### Auto-Wait Rod automatically retries element queries until the element appears or the context times out. You do not need manual sleeps: ```go // This will automatically wait until the element exists el := page.MustElement("#dynamic-content") // Wait until the element is stable (position/size not changing) el.MustWaitStable().MustClick() // Wait until page has no pending network requests wait := page.MustWaitRequestIdle() page.MustElement("#search").MustInput("query") wait() ``` --- ## Stealth & Anti-Bot Detection (go-rod/stealth) > **IMPORTANT:** For any production scraping or automation against real websites, ALWAYS use `stealth.MustPage()` instead of `browser.MustPage()`. This is the single most important step for avoiding bot detection. ### How Stealth Works The `go-rod/stealth` package injects JavaScript evasions into every new page that: - **Remove `navigator.webdriver`** — the primary headless detection signal. - **Spoof WebGL vendor/renderer** — presents real GPU info (e.g., "Intel Inc." / "Intel Iris OpenGL Engine") instead of headless markers like "Google SwiftShader". - **Fix Chrome plugin array** — reports proper `PluginArray` type with realistic plugin count. - **Patch permissions API** — returns `"prompt"` instead of bot-revealing values. - **Set realistic languages** — reports `en-US,en` instead of empty arrays. - **Fix broken image dimensions** — headless browsers report 0x0; stealth fixes this to 16x16. ### Usage **Creating a stealth page (recommended for all production use):** ```go import ( "github.com/go-rod/rod" "github.com/go-rod/stealth" ) browser := rod.New().MustConnect() defer browser.MustClose() // Use stealth.MustPage instead of browser.MustPage page := stealth.MustPage(browser) page.MustNavigate("https://bot.sannysoft.com") ``` **With error handling:** ```go page, err := stealth.Page(browser) if err != nil { return fmt.Errorf("failed to create stealth page: %w", err) } page.MustNavigate("https://example.com") ``` **Using stealth.JS directly (advanced — for custom page creation):** ```go // If you need to create the page yourself (e.g., with specific options), // inject stealth.JS manually via EvalOnNewDocument page := browser.MustPage() page.MustEvalOnNewDocument(stealth.JS) page.MustNavigate("https://example.com") ``` ### Verifying Stealth Navigate to a bot detection test page to verify evasions: ```go page := stealth.MustPage(browser) page.MustNavigate("https://bot.sannysoft.com") page.MustScreenshot("stealth_test.png") ``` Expected results for a properly stealth-configured browser: - **WebDriver**: `missing (passed)` - **Chrome**: `present (passed)` - **Plugins Length**: `3` (not `0`) - **Languages**: `en-US,en` --- ## Implementation Guidelines ### 1. Launcher Configuration Use the `launcher` package to customize browser launch flags: ```go import "github.com/go-rod/rod/lib/launcher" url := launcher.New(). Headless(true). // false for debugging Proxy("127.0.0.1:8080"). // upstream proxy Set("disable-gpu", ""). // custom Chrome flag Delete("use-mock-keychain"). // remove a default flag MustLaunch() browser := rod.New().ControlURL(url).MustConnect() defer browser.MustClose() ``` **Debugging mode (visible browser + slow motion):** ```go l := launcher.New(). Headless(false). Devtools(true) defer l.Cleanup() browser := rod.New(). ControlURL(l.MustLaunch()). Trace(true). SlowMotion(2 * time.Second). MustConnect() ``` ### 2. Proxy Support ```go // Set proxy at launch url := launcher.New(). Proxy("socks5://127.0.0.1:1080"). MustLaunch() browser := rod.New().ControlURL(url).MustConnect() // Handle proxy authentication go browser.MustHandleAuth("username", "password")() // Ignore SSL certificate errors (for MITM proxies) browser.MustIgnoreCertErrors(true) ``` ### 3. Input Simulation ```go import "github.com/go-rod/rod/lib/input" // Type into an input field (replaces existing value) page.MustElement("#email").MustInput("user@example.com") // Simulate keyboard keys page.Keyboard.MustType(input.Enter) // Press key combinations page.Keyboard.MustPress(input.ControlLeft) page.Keyboard.MustType(input.KeyA) page.Keyboard.MustRelease(input.ControlLeft) // Mouse click at coordinates page.Mouse.MustClick(input.MouseLeft) page.Mouse.MustMoveTo(100, 200) ``` ### 4. Network Request Interception (Hijacking) ```go router := browser.HijackRequests() defer router.MustStop() // Block all image requests router.MustAdd("*.png", func(ctx *rod.Hijack) { ctx.Response.Fail(proto.NetworkErrorReasonBlockedByClient) }) // Modify request headers router.MustAdd("*api.example.com*", func(ctx *rod.Hijack) { ctx.Request.Req().Header.Set("Authorization", "Bearer token123") ctx.MustLoadResponse() }) // Modify response body router.MustAdd("*.js", func(ctx *rod.Hijack) { ctx.MustLoadResponse() ctx.Response.SetBody(ctx.Response.Body() + "\n// injected") }) go router.Run() ``` ### 5. Waiting Strategies ```go // Wait for page load event page.MustWaitLoad() // Wait for no pending network requests (AJAX idle) wait := page.MustWaitRequestIdle() page.MustElement("#search").MustInput("query") wait() // Wait for element to be stable (not animating) page.MustElement(".modal").MustWaitStable().MustClick() // Wait for element to become invisible page.MustElement(".loading").MustWaitInvisible() // Wait for JavaScript condition page.MustWait(`() => document.title === 'Ready'`) // Wait for specific navigation/event wait := page.WaitEvent(&proto.PageLoadEventFired{}) page.MustNavigate("https://example.com") wait() ``` ### 6. Race Selectors (Multiple Outcomes) Handle pages where the result can be one of several outcomes (e.g., login success vs error): ```go page.MustElement("#username").MustInput("user") page.MustElement("#password").MustInput("pass").MustType(input.Enter) // Race between success and error selectors elm := page.Race(). Element(".dashboard").MustHandle(func(e *rod.Element) { fmt.Println("Login successful:", e.MustText()) }). Element(".error-message").MustDo() if elm.MustMatches(".error-message") { log.Fatal("Login failed:", elm.MustText()) } ``` ### 7. Screenshots & PDF ```go // Full-page screenshot page.MustScreenshot("page.png") // Custom screenshot (JPEG, specific region) img, _ := page.Screenshot(true, &proto.PageCaptureScreenshot{ Format: proto.PageCaptureScreenshotFormatJpeg, Quality: gson.Int(90), Clip: &proto.PageViewport{ X: 0, Y: 0, Width: 1280, Height: 800, Scale: 1, }, }) utils.OutputFile("screenshot.jpg", img) // Scroll screenshot (captures full scrollable page) img, _ := page.MustWaitStable().ScrollScreenshot(nil) utils.OutputFile("full_page.jpg", img) // PDF export page.MustPDF("output.pdf") ``` ### 8. Concurrent Page Pool ```go pool := rod.NewPagePool(5) // max 5 concurrent pages create := func() *rod.Page { return browser.MustIncognito().MustPage() } var wg sync.WaitGroup for _, url := range urls { wg.Add(1) go func(u string) { defer wg.Done() page := pool.MustGet(create) defer pool.Put(page) page.MustNavigate(u).MustWaitLoad() fmt.Println(page.MustInfo().Title) }(url) } wg.Wait() pool.Cleanup(func(p *rod.Page) { p.MustClose() }) ``` ### 9. Event Handling ```go // Listen for console.log output go page.EachEvent(func(e *proto.RuntimeConsoleAPICalled) { if e.Type == proto.RuntimeConsoleAPICalledTypeLog { fmt.Println(page.MustObjectsToJSON(e.Args)) } })() // Wait for a specific event before proceeding wait := page.WaitEvent(&proto.PageLoadEventFired{}) page.MustNavigate("https://example.com") wait() ``` ### 10. File Download ```go wait := browser.MustWaitDownload() page.MustElementR("a", "Download PDF").MustClick() data := wait() utils.OutputFile("downloaded.pdf", data) ``` ### 11. JavaScript Evaluation ```go // Execute JS on the page page.MustEval(`() => console.log("hello")`) // Pass parameters and get return value result := page.MustEval(`(a, b) => a + b`, 1, 2) fmt.Println(result.Int()) // 3 // Eval on a specific element ("this" = the DOM element) title := page.MustElement("title").MustEval(`() => this.innerText`).String() // Direct CDP calls for features Rod doesn't wrap proto.PageSetAdBlockingEnabled{Enabled: true}.Call(page) ``` ### 12. Loading Chrome Extensions ```go extPath, _ := filepath.Abs("./my-extension") u := launcher.New(). Set("load-extension", extPath). Headless(false). // extensions require headed mode MustLaunch() browser := rod.New().ControlURL(u).MustConnect() ``` --- ## Examples See the `examples/` directory for complete, runnable Go files: - `examples/basic_scrape.go` — Minimal scraping example - `examples/stealth_page.go` — Anti-detection with go-rod/stealth - `examples/request_hijacking.go` — Intercepting and modifying network requests - `examples/concurrent_pages.go` — Page pool for concurrent scraping --- ## Best Practices - ✅ **ALWAYS use `stealth.MustPage(browser)`** instead of `browser.MustPage()` for real-world sites. - ✅ **ALWAYS `defer browser.MustClose()`** immediately after connecting. - ✅ Use the error-returning API (not `Must*`) in production code. - ✅ Set explicit timeouts with `.Timeout()` — never rely on defaults for production. - ✅ Use `browser.MustIncognito().MustPage()` for isolated sessions. - ✅ Use `PagePool` for concurrent scraping instead of spawning unlimited pages. - ✅ Use `MustWaitStable()` before clicking elements that might be animating. - ✅ Use `MustWaitRequestIdle()` after actions that trigger AJAX calls. - ✅ Use `launcher.New().Headless(false).Devtools(true)` for debugging. - ❌ **NEVER** use `time.Sleep()` for waiting — use Rod's built-in wait methods. - ❌ **NEVER** create a new `Browser` per task — create one Browser, use multiple `Page` instances. - ❌ **NEVER** use `browser.MustPage()` for production scraping — use `stealth.MustPage()`. - ❌ **NEVER** ignore errors in production — always handle them explicitly. - ❌ **NEVER** forget to defer-close browsers, pages, and hijack routers. ## Common Pitfalls - **Problem:** Element not found even though it exists on the page. **Solution:** The element may be inside an iframe or shadow DOM. Use `page.MustSearch()` instead of `page.MustElement()` — it searches across all iframes and shadow DOMs. - **Problem:** Click doesn't work because the element is animating. **Solution:** Call `el.MustWaitStable()` before `el.MustClick()`. - **Problem:** Bot detection despite using stealth. **Solution:** Combine `stealth.MustPage()` with: randomized viewport sizes, realistic User-Agent strings, human-like input delays between keystrokes, and random idle behaviors (scroll, hover). - **Problem:** Browser process leaks (zombie processes). **Solution:** Always `defer browser.MustClose()`. Rod uses [leakless](https://github.com/ysmood/leakless) to kill zombies after main process crash, but explicit cleanup is preferred. - **Problem:** Timeout errors on slow pages. **Solution:** Use chained context: `page.Timeout(30 * time.Second).MustWaitLoad()`. For AJAX-heavy pages, use `MustWaitRequestIdle()` instead of `MustWaitLoad()`. - **Problem:** HijackRequests router not intercepting requests. **Solution:** You must call `go router.Run()` after setting up routes, and `defer router.MustStop()` for cleanup. ## Limitations - **CAPTCHAs:** Rod does not include CAPTCHA solving. External services (2captcha, etc.) must be integrated separately. - **Extreme Anti-Bot:** While `go-rod/stealth` handles common detection (WebDriver, plugin fingerprints, WebGL), extremely strict systems (some Cloudflare configurations, Akamai Bot Manager) may still detect automation. Additional measures (residential proxies, human-like behavioral patterns) may be needed. - **DRM Content:** Cannot interact with DRM-protected media (e.g., Widevine). - **Resource Usage:** Each browser instance consumes significant RAM (~100-300MB+). Use `PagePool` and limit concurrency on memory-constrained systems. - **Extensions in Headless:** Chrome extensions do not work in headless mode. Use `Headless(false)` with XVFB for server environments. - **Platform:** Requires a Chromium-compatible browser. Does not support Firefox or Safari. ## Documentation References - [Official Documentation](https://go-rod.github.io/) — Guides, tutorials, FAQ - [Go API Reference](https://pkg.go.dev/github.com/go-rod/rod) — Complete type and method documentation - [go-rod/stealth](https://github.com/go-rod/stealth) — Anti-bot detection plugin - [Examples (source)](https://github.com/go-rod/rod/blob/main/examples_test.go) — Official example tests - [Rod vs Chromedp Comparison](https://github.com/nichochar/go-rod.github.io/blob/main/lib/examples/compare-chromedp) — Migration reference - [Chrome DevTools Protocol Docs](https://chromedevtools.github.io/devtools-protocol/) — Underlying protocol reference - [Chrome CLI Flags Reference](https://peter.sh/experiments/chromium-command-line-switches) — Launcher flag documentation - `references/api-reference.md` — Quick-reference cheat sheet --- ## AGI Framework Integration > **Adapted for [@techwavedev/agi-agent-kit](https://www.npmjs.com/package/@techwavedev/agi-agent-kit)** > Original source: [antigravity-awesome-skills](https://github.com/sickn33/antigravity-awesome-skills) ### Memory-First Protocol Cache workflow configurations and automation patterns. Retrieve prior pipeline designs to avoid re-building similar flows from scratch. ```bash # Check for prior workflow/automation context before starting python3 execution/memory_manager.py auto --query "automation patterns and workflow configurations for Go Rod Master" ``` ### Storing Results After completing work, store workflow/automation decisions for future sessions: ```bash python3 execution/memory_manager.py store \ --content "Workflow: automated data pipeline with retry logic, dead-letter queue, and Slack alerts on failure" \ --type technical --project \ --tags go-rod-master workflow ``` ### Multi-Agent Collaboration Share workflow state with other agents so they can trigger, monitor, or extend the automation. ```bash python3 execution/cross_agent_context.py store \ --agent "" \ --action "Workflow automation deployed — pipeline processing 1000+ events/day with 99.9% success rate" \ --project ``` ### Playbook Engine Combine this skill with others using the Playbook Engine (`execution/workflow_engine.py`) for guided multi-step automation with progress tracking. --- Source attribution: techwavedev Original project: https://github.com/techwavedev/agi-agent-kit/blob/58f5d95434a1adc8b41a4f391d32d95311e54936/templates/skills/extended/workflow/go-rod-master/SKILL.md License: Apache-2.0 License information: https://www.apache.org/licenses/LICENSE-2.0 Original upstream instructions; downloaded from Mega AI Hub. ## Upstream license notice Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to the Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright 2024-2026 Elton Machado (TechWaveDev) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. # Mega AI Hub resource metadata Creator / publisher: techwavedev Original project: https://github.com/techwavedev/agi-agent-kit/blob/58f5d95434a1adc8b41a4f391d32d95311e54936/templates/skills/extended/workflow/go-rod-master/SKILL.md Attribution basis: Source repository record Fields of work: Development & Engineering Roles: Backend Developer, Data Engineer, QA / Test Engineer Specialties: API, Backend, Design, DevOps, Word Documents, Frontend, Git, Playwright, React, Testing Tools: Chrome Devtools Protocol, Go Country applicability: Country not specified Classification basis: Source catalog labels Instruction SHA-256: 9e40d83d8fb746e06b9de678e47f72ef2d4aa35d6d7f13b53b34e2f113238f14