# Authentication
Source: https://agent.palank.co.kr/api-reference/authentication

Session management and connection handling

## Overview

PalanK's local API does not require authentication tokens. Security is enforced through:

1. **Local-only connections**: Only `127.0.0.1` and `localhost` are allowed
2. **Session-based**: Each browser tab attachment creates a unique session

## Sessions

### Session Creation

When the Chrome extension attaches to a tab, a session is automatically created:

```json theme={null}
// Event sent from extension to your app
{
  "method": "forwardCDPEvent",
  "params": {
    "method": "Target.attachedToTarget",
    "params": {
      "sessionId": "cb-tab-1",
      "targetInfo": {
        "targetId": "ABC123",
        "type": "page",
        "title": "Google",
        "url": "https://google.com",
        "attached": true
      }
    }
  }
}
```

### Using Session IDs

Include the `sessionId` in commands to target specific tabs:

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "sessionId": "cb-tab-1",
    "method": "Page.navigate",
    "params": {
      "url": "https://example.com"
    }
  }
}
```

### Session Termination

When a tab is detached or closed:

```json theme={null}
// Event notification
{
  "method": "forwardCDPEvent",
  "params": {
    "method": "Target.detachedFromTarget",
    "params": {
      "sessionId": "cb-tab-1",
      "targetId": "ABC123",
      "reason": "user_detached"
    }
  }
}
```

## Connection Lifecycle

### Handshake

```mermaid theme={null}
sequenceDiagram
    participant App as Your App
    participant GW as Gateway
    participant Ext as Extension

    App->>GW: WebSocket Connect
    GW-->>App: Connection Open

    Note over App,GW: Connection established

    GW->>App: ping
    App->>GW: pong

    Note over App,GW: Keepalive loop
```

### Keepalive

The Gateway sends periodic `ping` messages. Respond with `pong`:

```json theme={null}
// Received
{"method": "ping"}

// Send back
{"method": "pong"}
```

<Warning>
  Failure to respond to `ping` messages may result in connection termination.
</Warning>

## Multiple Tabs

You can work with multiple tabs simultaneously:

```json theme={null}
// Tab 1 session
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "sessionId": "cb-tab-1",
    "method": "Page.navigate",
    "params": {"url": "https://site-a.com"}
  }
}

// Tab 2 session
{
  "id": 2,
  "method": "forwardCDPCommand",
  "params": {
    "sessionId": "cb-tab-2",
    "method": "Page.navigate",
    "params": {"url": "https://site-b.com"}
  }
}
```

## Error Handling

### No Active Session

```json theme={null}
{
  "id": 1,
  "error": "No attached tab for method Page.navigate"
}
```

**Solution**: Ensure the Chrome extension is attached to a tab before sending commands.

### Invalid Session ID

```json theme={null}
{
  "id": 1,
  "error": "Session not found: cb-tab-99"
}
```

**Solution**: Use a valid session ID from a `Target.attachedToTarget` event.

### Connection Lost

If the WebSocket disconnects:

1. All pending commands will fail
2. Tabs remain attached in Chrome
3. Reconnect to resume operations

## Best Practices

<CardGroup>
  <Card title="Track Sessions" icon="list">
    Maintain a list of active session IDs from attach/detach events
  </Card>

  <Card title="Handle Disconnects" icon="plug">
    Implement reconnection logic for robustness
  </Card>

  <Card title="Default Session" icon="crosshairs">
    Without sessionId, commands go to the first attached tab
  </Card>

  <Card title="Clean Up" icon="broom">
    Handle detach events to remove stale sessions
  </Card>
</CardGroup>


# Endpoints
Source: https://agent.palank.co.kr/api-reference/endpoints

Available API methods and their usage

## CDP Command Forwarding

The primary method for browser control is `forwardCDPCommand`, which proxies Chrome DevTools Protocol commands.

### forwardCDPCommand

<ParamField type="string">
  The CDP method to execute (e.g., `Page.navigate`)
</ParamField>

<ParamField type="object">
  Parameters for the CDP method
</ParamField>

<ParamField type="string">
  Target session ID (optional - defaults to first attached tab)
</ParamField>

## Navigation

### Page.navigate

Navigate to a URL.

<CodeGroup>
  ```json Request theme={null}
  {
    "id": 1,
    "method": "forwardCDPCommand",
    "params": {
      "method": "Page.navigate",
      "params": {
        "url": "https://example.com"
      }
    }
  }
  ```

  ```json Response theme={null}
  {
    "id": 1,
    "result": {
      "frameId": "ABC123",
      "loaderId": "DEF456"
    }
  }
  ```
</CodeGroup>

### Page.reload

Reload the current page.

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "Page.reload",
    "params": {
      "ignoreCache": true
    }
  }
}
```

## Tab Management

### Target.createTarget

Open a new tab.

<CodeGroup>
  ```json Request theme={null}
  {
    "id": 1,
    "method": "forwardCDPCommand",
    "params": {
      "method": "Target.createTarget",
      "params": {
        "url": "https://example.com"
      }
    }
  }
  ```

  ```json Response theme={null}
  {
    "id": 1,
    "result": {
      "targetId": "XYZ789"
    }
  }
  ```
</CodeGroup>

### Target.closeTarget

Close a tab.

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "Target.closeTarget",
    "params": {
      "targetId": "XYZ789"
    }
  }
}
```

### Target.activateTarget

Bring a tab to focus.

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "Target.activateTarget",
    "params": {
      "targetId": "XYZ789"
    }
  }
}
```

## JavaScript Execution

### Runtime.evaluate

Execute JavaScript in the page context.

<CodeGroup>
  ```json Request theme={null}
  {
    "id": 1,
    "method": "forwardCDPCommand",
    "params": {
      "method": "Runtime.evaluate",
      "params": {
        "expression": "document.title",
        "returnByValue": true
      }
    }
  }
  ```

  ```json Response theme={null}
  {
    "id": 1,
    "result": {
      "result": {
        "type": "string",
        "value": "Example Domain"
      }
    }
  }
  ```
</CodeGroup>

## Input Events

### Input.dispatchMouseEvent

Simulate mouse actions.

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "Input.dispatchMouseEvent",
    "params": {
      "type": "mousePressed",
      "x": 100,
      "y": 200,
      "button": "left",
      "clickCount": 1
    }
  }
}
```

Mouse event types:

* `mousePressed`
* `mouseReleased`
* `mouseMoved`

### Input.dispatchKeyEvent

Simulate keyboard input.

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "Input.dispatchKeyEvent",
    "params": {
      "type": "keyDown",
      "key": "Enter"
    }
  }
}
```

## Screenshots

### Page.captureScreenshot

Capture the visible page area.

<CodeGroup>
  ```json Request theme={null}
  {
    "id": 1,
    "method": "forwardCDPCommand",
    "params": {
      "method": "Page.captureScreenshot",
      "params": {
        "format": "png",
        "quality": 100
      }
    }
  }
  ```

  ```json Response theme={null}
  {
    "id": 1,
    "result": {
      "data": "iVBORw0KGgoAAAANSUhEUgA..."
    }
  }
  ```
</CodeGroup>

<Note>
  The `data` field contains base64-encoded image data.
</Note>

## DOM Operations

### DOM.getDocument

Get the document root node.

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "DOM.getDocument",
    "params": {
      "depth": 2
    }
  }
}
```

### DOM.querySelector

Find an element by CSS selector.

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "DOM.querySelector",
    "params": {
      "nodeId": 1,
      "selector": "#search-input"
    }
  }
}
```

## Events

The Gateway forwards CDP events from the browser:

```json theme={null}
{
  "method": "forwardCDPEvent",
  "params": {
    "sessionId": "cb-tab-1",
    "method": "Page.loadEventFired",
    "params": {
      "timestamp": 12345.678
    }
  }
}
```

Common events:

* `Page.loadEventFired` - Page finished loading
* `Page.frameNavigated` - Frame navigation completed
* `Runtime.consoleAPICalled` - Console message logged
* `Target.attachedToTarget` - Tab attached
* `Target.detachedFromTarget` - Tab detached

## Full CDP Reference

For complete CDP documentation, see:

* [Chrome DevTools Protocol Viewer](https://chromedevtools.github.io/devtools-protocol/)
* [Page Domain](https://chromedevtools.github.io/devtools-protocol/tot/Page/)
* [Runtime Domain](https://chromedevtools.github.io/devtools-protocol/tot/Runtime/)
* [Input Domain](https://chromedevtools.github.io/devtools-protocol/tot/Input/)
* [DOM Domain](https://chromedevtools.github.io/devtools-protocol/tot/DOM/)


# API Introduction
Source: https://agent.palank.co.kr/api-reference/introduction

Integrate PalanK capabilities into your applications

## Overview

PalanK exposes a local API that allows external applications to leverage its browser automation capabilities. The API communicates via WebSocket with the local Gateway server.

<Note>
  The API is designed for local integrations only. All connections are restricted to `127.0.0.1`.
</Note>

## Architecture

```mermaid theme={null}
graph LR
    A[Your Application] -->|WebSocket| B[PalanK Gateway]
    B --> C[Chrome Extension]
    C --> D[Browser Tab]
    B --> E[Claude AI]
```

## Connection

### WebSocket Endpoint

```
ws://127.0.0.1:18792/extension
```

### HTTP Health Check

```
GET http://127.0.0.1:18792/
```

Returns `200 OK` if the Gateway is running.

## Message Format

All messages use JSON format:

### Request

```json theme={null}
{
  "id": 1,
  "method": "forwardCDPCommand",
  "params": {
    "method": "Page.navigate",
    "params": {
      "url": "https://example.com"
    }
  }
}
```

### Response

```json theme={null}
{
  "id": 1,
  "result": {
    "frameId": "ABC123",
    "loaderId": "DEF456"
  }
}
```

### Error Response

```json theme={null}
{
  "id": 1,
  "error": "No attached tab for method Page.navigate"
}
```

## Quick Start

<CodeGroup>
  ```javascript Node.js theme={null}
  const WebSocket = require('ws');

  const ws = new WebSocket('ws://127.0.0.1:18792/extension');

  ws.on('open', () => {
    ws.send(JSON.stringify({
      id: 1,
      method: 'forwardCDPCommand',
      params: {
        method: 'Page.navigate',
        params: { url: 'https://google.com' }
      }
    }));
  });

  ws.on('message', (data) => {
    console.log('Response:', JSON.parse(data));
  });
  ```

  ```python Python theme={null}
  import websocket
  import json

  ws = websocket.create_connection('ws://127.0.0.1:18792/extension')

  ws.send(json.dumps({
      'id': 1,
      'method': 'forwardCDPCommand',
      'params': {
          'method': 'Page.navigate',
          'params': {'url': 'https://google.com'}
      }
  }))

  result = json.loads(ws.recv())
  print('Response:', result)

  ws.close()
  ```
</CodeGroup>

## Available Methods

| Category   | Methods                                                              |
| ---------- | -------------------------------------------------------------------- |
| Navigation | `Page.navigate`, `Page.reload`, `Page.goBack`, `Page.goForward`      |
| DOM        | `DOM.getDocument`, `DOM.querySelector`, `DOM.getOuterHTML`           |
| Input      | `Input.dispatchMouseEvent`, `Input.dispatchKeyEvent`                 |
| Runtime    | `Runtime.evaluate`, `Runtime.callFunctionOn`                         |
| Target     | `Target.createTarget`, `Target.closeTarget`, `Target.activateTarget` |

<Info>
  The API supports most [Chrome DevTools Protocol](https://chromedevtools.github.io/devtools-protocol/) methods.
</Info>

## Next Steps

<CardGroup>
  <Card title="Authentication" icon="key" href="/api-reference/authentication">
    Learn about session management
  </Card>

  <Card title="Endpoints" icon="route" href="/api-reference/endpoints">
    Explore all available endpoints
  </Card>
</CardGroup>


# Browser Extension
Source: https://agent.palank.co.kr/browser-extension

Install and configure PalanK Browser Relay for Chrome

## Overview

PalanK Browser Relay is a lightweight Chrome extension that connects your browser tabs to PalanK Agent. It uses Chrome's built-in debugging protocol (CDP) to enable AI-powered browser automation.

<Info>
  The extension only activates on tabs you explicitly attach. Your browsing history and data are never collected.
</Info>

## Installation

### Chrome Web Store (Recommended)

<Card title="Install from Chrome Web Store" icon="chrome" href="https://chrome.google.com/webstore/detail/palank-browser-relay">
  One-click installation with automatic updates
</Card>

### Manual Installation (Developer Mode)

For testing or development purposes:

<Steps>
  <Step title="Download Extension">
    Download the extension files from [GitHub releases](https://github.com/PALAN-K/palank-opemclaw/releases).
  </Step>

  <Step title="Open Extensions Page">
    Navigate to `chrome://extensions` in Chrome.
  </Step>

  <Step title="Enable Developer Mode">
    Toggle "Developer mode" in the top right corner.
  </Step>

  <Step title="Load Extension">
    Click "Load unpacked" and select the extension folder.
  </Step>
</Steps>

## Usage

### Attaching a Tab

1. Navigate to the webpage you want to control
2. Click the PalanK Browser Relay icon in the toolbar
3. Wait for the badge to show "ON"

<Warning>
  Chrome will show a warning: "PalanK Browser Relay started debugging this browser". This is normal - it's how the extension controls the page.
</Warning>

### Detaching a Tab

Click the extension icon again to disconnect. The badge will disappear.

### Badge Status

| Badge            | Meaning                                     |
| ---------------- | ------------------------------------------- |
| **ON** (orange)  | Tab is connected and ready                  |
| **...** (yellow) | Connecting to relay server                  |
| **!** (red)      | Cannot reach relay - PalanK app not running |
| (none)           | Tab not attached                            |

## Configuration

### Changing Relay Port

If you've configured PalanK to use a different port:

1. Right-click the extension icon → Options
2. Enter the new port number
3. Click Save

<Note>
  Default port is `18792`. Only change this if you've modified PalanK's CDP settings.
</Note>

## How It Works

```mermaid theme={null}
sequenceDiagram
    participant User
    participant Extension
    participant Gateway as PalanK Gateway
    participant AI as Claude AI

    User->>Extension: Click icon
    Extension->>Gateway: WebSocket connect
    Gateway-->>Extension: Connected
    Extension->>Extension: Attach debugger
    Note over Extension: Badge shows ON

    AI->>Gateway: Send command
    Gateway->>Extension: Forward CDP command
    Extension->>Extension: Execute on page
    Extension->>Gateway: Return result
    Gateway->>AI: Command result
```

## Permissions

The extension requires these permissions:

| Permission         | Purpose                                   |
| ------------------ | ----------------------------------------- |
| `debugger`         | Control page via Chrome DevTools Protocol |
| `tabs`             | Access current tab information            |
| `activeTab`        | Interact with active tab when clicked     |
| `storage`          | Save relay port configuration             |
| `host_permissions` | Connect to local relay server             |

<Check>
  All communication stays on `127.0.0.1` (localhost). No data is sent to external servers.
</Check>

## Limitations

The extension cannot control:

* Chrome internal pages (`chrome://`, `edge://`)
* Chrome Web Store pages
* Other extensions' pages
* PDF viewer

## Troubleshooting

<AccordionGroup>
  <Accordion icon="server" title="Relay not reachable">
    Make sure PalanK Desktop app is running. The extension needs the local gateway server to function.
  </Accordion>

  <Accordion icon="refresh" title="Extension stops working after Chrome update">
    Go to `chrome://extensions`, disable and re-enable the extension.
  </Accordion>

  <Accordion icon="lock" title="Page not responding to commands">
    Some pages with strict Content Security Policy may limit functionality. Try refreshing the page after attaching.
  </Accordion>
</AccordionGroup>


# AI Assistant
Source: https://agent.palank.co.kr/features/ai-assistant

Powered by Claude AI for intelligent browser automation

## Overview

PalanK is powered by Claude, Anthropic's AI assistant. This enables natural language understanding, context awareness, and intelligent decision-making for browser automation.

## Natural Language Commands

### Conversational Style

You don't need special syntax. Just describe what you want:

```text theme={null}
"I need to check my email on Gmail"
"Can you help me find flights to Tokyo next month?"
"Look up the weather forecast for this weekend"
```

### Multi-Step Tasks

The AI breaks down complex requests automatically:

```text theme={null}
"Log into my account, go to settings, and change my password"

AI executes:
1. Navigate to login page
2. Enter credentials
3. Click login
4. Find settings menu
5. Navigate to password section
6. Initiate password change
```

## Context Awareness

### Page Understanding

The AI analyzes the current page to understand:

* Page structure and layout
* Interactive elements (buttons, forms, links)
* Content and context
* User flow and navigation patterns

### Memory

Within a session, the AI remembers:

* Previous commands and results
* Information you've shared
* Errors encountered and how they were resolved

```text theme={null}
User: "Go to amazon.com and search for laptop"
AI: [executes search]

User: "Now filter by price under $500"
AI: [understands context, applies filter]

User: "Click on the first result"
AI: [knows we're looking at laptops under $500]
```

## Intelligent Error Handling

### Auto-Recovery

When something goes wrong, the AI attempts to recover:

```text theme={null}
Command: "Click the checkout button"

If button not visible:
- AI scrolls to find it
- Waits for page load if needed
- Reports if button doesn't exist
```

### Clear Feedback

The AI explains what it's doing and any issues:

```text theme={null}
"I couldn't find a 'checkout' button. I see a 'Proceed to Cart'
button instead. Should I click that?"
```

## Supported Languages

PalanK understands commands in multiple languages:

* English
* Korean (한국어)
* Japanese (日本語)
* Chinese (中文)
* Spanish (Español)
* And more...

## Tips for Better Results

<CardGroup>
  <Card title="Be Specific" icon="bullseye">
    "Click the red Add to Cart button" works better than "click the button"
  </Card>

  <Card title="Provide Context" icon="lightbulb">
    "I'm trying to book a hotel for 2 nights" helps AI understand your goal
  </Card>

  <Card title="Ask Questions" icon="question">
    "What options do I have here?" lets AI analyze the page for you
  </Card>

  <Card title="Iterate" icon="arrows-rotate">
    If first attempt fails, try rephrasing or providing more detail
  </Card>
</CardGroup>

## What AI Can't Do

<Warning>
  The AI cannot:

  * Access your saved passwords or autofill data
  * Interact with native OS dialogs
  * Bypass CAPTCHAs or security measures
  * Access pages you're not logged into
</Warning>


# Automation
Source: https://agent.palank.co.kr/features/automation

Automate repetitive web tasks with AI assistance

## Overview

PalanK helps you automate repetitive browser tasks without writing code. Describe what you want to accomplish, and the AI handles the implementation.

## Common Automation Scenarios

### Data Collection

```text theme={null}
"Go through each product on this page and collect the name, price, and rating"

"Scrape all job listings from this search result"

"Extract all email addresses from this contact page"
```

### Form Filling

```text theme={null}
"Fill out this registration form:
- Name: John Doe
- Email: john@example.com
- Company: Acme Inc"

"Auto-fill shipping address with my saved information"
```

### Monitoring

```text theme={null}
"Check if this product is back in stock"

"Look for any price changes on this item"

"Tell me when the status changes from 'Pending' to 'Approved'"
```

### Batch Operations

```text theme={null}
"Download all images from this gallery"

"Like all posts from this user"

"Mark all unread emails as read"
```

## Workflow Examples

### E-commerce Price Comparison

<Steps>
  <Step title="Define Products">
    "I want to compare prices for 'Sony WH-1000XM5 headphones'"
  </Step>

  <Step title="Check Multiple Sites">
    "Check Amazon, Best Buy, and Walmart for this product"
  </Step>

  <Step title="Collect Results">
    "Give me a summary of prices from each site"
  </Step>
</Steps>

### Social Media Management

<Steps>
  <Step title="Navigate">
    "Go to my Twitter profile"
  </Step>

  <Step title="Analyze">
    "Show me my recent posts with the most engagement"
  </Step>

  <Step title="Act">
    "Reply to the top comment with a thank you message"
  </Step>
</Steps>

### Research Automation

<Steps>
  <Step title="Search">
    "Search Google Scholar for 'machine learning healthcare'"
  </Step>

  <Step title="Filter">
    "Filter results from the last 2 years"
  </Step>

  <Step title="Extract">
    "List the titles and authors of the first 10 results"
  </Step>
</Steps>

## Best Practices

<AccordionGroup>
  <Accordion icon="clock" title="Handle Timing">
    Web pages load at different speeds. Include "wait for page to load" when navigating between pages.
  </Accordion>

  <Accordion icon="shield-check" title="Respect Limits">
    Don't automate actions that violate website terms of service. Be mindful of rate limits.
  </Accordion>

  <Accordion icon="arrows-split-up-and-left" title="Break Down Tasks">
    For complex workflows, describe one step at a time rather than everything at once.
  </Accordion>

  <Accordion icon="bug" title="Verify Results">
    Ask the AI to confirm actions were successful: "Did the form submit correctly?"
  </Accordion>
</AccordionGroup>

## Limitations

<Warning>
  **Rate Limiting**: Rapid automated actions may trigger website security measures.

  **Dynamic Content**: Some sites load content dynamically, requiring wait commands.

  **Authentication**: The AI cannot bypass login requirements or CAPTCHAs.
</Warning>

## Privacy Considerations

<Info>
  All automation runs locally on your machine. PalanK does not store or transmit your browsing data to external servers. Only your commands are sent to Claude AI for interpretation.
</Info>


# Browser Control
Source: https://agent.palank.co.kr/features/browser-control

Control Chrome tabs with AI-powered commands

## Overview

PalanK provides comprehensive browser automation through natural language commands. The AI understands context and executes complex multi-step operations automatically.

## Navigation

### Page Navigation

```text theme={null}
"Go to amazon.com"
"Navigate to https://github.com/PALAN-K"
"Open google.com in a new tab"
"Go back to the previous page"
"Refresh this page"
```

### Tab Management

```text theme={null}
"Open a new tab"
"Close this tab"
"Switch to the second tab"
```

## Interactions

### Clicking Elements

```text theme={null}
"Click the login button"
"Click on the search icon"
"Click the first product in the list"
"Double-click on the image"
```

### Typing Text

```text theme={null}
"Type 'hello world' in the search box"
"Fill the email field with test@example.com"
"Enter my username in the login form"
"Clear the input field and type 'new text'"
```

### Form Handling

```text theme={null}
"Fill out the contact form with my information"
"Select 'United States' from the country dropdown"
"Check the 'Remember me' checkbox"
"Submit the form"
```

## Page Analysis

### Reading Content

```text theme={null}
"What's the title of this page?"
"Read the main article content"
"List all the links on this page"
"Find the price of this product"
```

### Screenshots

```text theme={null}
"Take a screenshot"
"Capture the visible area"
"Screenshot the entire page"
```

### Element Finding

```text theme={null}
"Find all buttons on this page"
"Locate the login form"
"Where is the search bar?"
```

## Scrolling

```text theme={null}
"Scroll down"
"Scroll to the bottom of the page"
"Scroll up a little"
"Scroll to the comments section"
```

## Advanced Operations

### Waiting

```text theme={null}
"Wait for the page to load"
"Wait until the spinner disappears"
"Wait 3 seconds"
```

### Conditional Actions

```text theme={null}
"If there's a cookie banner, close it"
"Click 'Load more' until all items are visible"
"If logged in, go to dashboard; otherwise login first"
```

### Data Extraction

```text theme={null}
"Extract all product names and prices"
"Get the table data as CSV"
"Copy all email addresses on this page"
```

## Best Practices

<Tip>
  Be specific about which element you want to interact with. Instead of "click the button", say "click the blue Submit button at the bottom".
</Tip>

<Warning>
  The AI sees the page as a user would. If an element is hidden or requires scrolling, mention that in your command.
</Warning>

## Limitations

* Cannot interact with browser chrome (address bar, bookmarks)
* Cannot access cross-origin iframes with different security policies
* Some heavily protected sites may block automation
* File upload dialogs require manual interaction


# Introduction
Source: https://agent.palank.co.kr/introduction

Welcome to PalanK Agent - AI-Powered Browser Automation for Windows

<img alt="PalanK Agent Hero" />

<img alt="PalanK Agent Hero" />

## What is PalanK Agent?

PalanK Agent is a powerful AI-powered browser automation tool for Windows. Powered by **Antigravity CLI**, it provides free access to multiple AI models including Gemini 3 Pro, Gemini 3 Flash, Claude, and more. Automate web tasks through natural language commands with your choice of AI model.

<CardGroup>
  <Card title="Quick Start" icon="rocket" href="/quickstart">
    Get up and running in minutes
  </Card>

  <Card title="Browser Extension" icon="puzzle-piece" href="/browser-extension">
    Install Chrome extension for browser control
  </Card>

  <Card title="Features" icon="sparkles" href="/features/browser-control">
    Explore all capabilities
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Integrate with your applications
  </Card>
</CardGroup>

## Key Features

<AccordionGroup>
  <Accordion icon="browser" title="Browser Automation">
    Control Chrome tabs through natural language. Click, type, scroll, and navigate - all through AI commands.
  </Accordion>

  <Accordion icon="robot" title="Multiple AI Models">
    Choose from Gemini 3 Pro, Gemini 3 Flash, Claude Opus/Sonnet/Haiku, and more. All models are free via Antigravity CLI.
  </Accordion>

  <Accordion icon="bolt" title="Local Processing">
    All processing happens on your machine. Your data stays private with no cloud dependency for browser control.
  </Accordion>

  <Accordion icon="puzzle-piece" title="Chrome Extension">
    Lightweight extension connects your existing Chrome tabs to PalanK. No separate browser needed.
  </Accordion>
</AccordionGroup>

## How It Works

```mermaid theme={null}
graph LR
    A[PalanK Desktop App] --> B[Local Gateway]
    B --> C[Chrome Extension]
    C --> D[Your Browser Tabs]
    A --> E[Claude AI]
    E --> A
```

1. **PalanK Desktop App** - Native Windows application with AI chat interface
2. **Local Gateway** - Secure local server for browser communication
3. **Chrome Extension** - Lightweight relay connecting browser to PalanK
4. **Claude AI** - Intelligent assistant understanding your commands

## Requirements

* Windows 10 or later
* Google Chrome browser
* Internet connection (for AI features)
* PalanK Browser Relay Chrome extension


# Privacy Policy
Source: https://agent.palank.co.kr/privacy

Privacy Policy for PalanK Browser Relay Chrome Extension

# Privacy Policy

**Last updated: February 3, 2026**

## Overview

PalanK Browser Relay ("the Extension") is a Chrome extension that connects your browser tabs to the PalanK desktop application for AI-powered browser automation. This privacy policy explains how the Extension handles your data.

## Data Collection

**We do not collect, store, or transmit any personal data.**

The Extension operates entirely locally on your device and does not send any information to external servers, except for communication with the locally running PalanK desktop application on your own machine.

## Permissions Explained

### Debugger Permission

The `debugger` permission is required to control browser tabs via Chrome DevTools Protocol (CDP). This allows the Extension to:

* Navigate web pages
* Click elements
* Fill forms
* Take screenshots
* Execute JavaScript

This permission is only activated when you explicitly click the Extension icon to attach a tab.

### Tabs Permission

The `tabs` permission is used to:

* Access information about the currently active tab (URL, title)
* Detect when tabs are opened, closed, or updated
* Manage tab attachment status

### ActiveTab Permission

The `activeTab` permission provides temporary access to the currently active tab only when you click the Extension icon. This limits access to tabs you explicitly choose to control.

### Storage Permission

The `storage` permission is used solely to save your relay port configuration locally. No data is synced to any cloud service.

### Host Permissions (localhost only)

The Extension only connects to `http://127.0.0.1/*` and `http://localhost/*`. This is strictly for communicating with the PalanK desktop application running on your local machine. No external network connections are made.

## Data Processing

* **Local only**: All browser automation happens locally between the Extension and PalanK desktop app
* **No analytics**: We do not use any analytics or tracking services
* **No cookies**: The Extension does not set or read any cookies
* **No external servers**: No data is transmitted outside your local machine

## Third-Party Services

The PalanK desktop application may communicate with Anthropic's Claude AI service to process your natural language commands. This communication is handled by the desktop application, not the browser extension. Please refer to [Anthropic's Privacy Policy](https://www.anthropic.com/privacy) for details on their data handling practices.

## Data Retention

The Extension does not retain any data. The only stored information is your relay port setting, which remains in Chrome's local storage until you uninstall the Extension or clear browser data.

## User Rights

Since we do not collect personal data, there is no data to access, modify, or delete. You can uninstall the Extension at any time to remove all associated local storage.

## Children's Privacy

The Extension is not directed at children under 13 years of age, and we do not knowingly collect personal information from children.

## Changes to This Policy

We may update this Privacy Policy from time to time. Changes will be posted on this page with an updated revision date.

## Contact

If you have questions about this Privacy Policy, please contact us at:

**Email**: [support@palank.co.kr](mailto:support@palank.co.kr)

**Website**: [https://palank.co.kr](https://palank.co.kr)


# Quick Start
Source: https://agent.palank.co.kr/quickstart

Get PalanK Agent running in under 5 minutes

## Step 1: Download PalanK

Download the latest version of PalanK Agent for Windows.

<CardGroup>
  <Card title="EXE (NSIS)" icon="download" href="https://github.com/naegeon/palank-openclaw/releases/download/v2.0.0/PalanK-OpenClaw_2.0.0_x64-setup.exe">
    28MB - Recommended for general users
  </Card>

  <Card title="MSI" icon="download" href="https://github.com/naegeon/palank-openclaw/releases/download/v2.0.0/PalanK-OpenClaw_2.0.0_x64_en-US.msi">
    41MB - For enterprise/IT administrators
  </Card>
</CardGroup>

<Note>
  On first launch, OpenClaw will be automatically installed.
</Note>

## Step 2: Install Chrome Extension

The Chrome extension allows PalanK to control your browser tabs.

<Steps>
  <Step title="Install Extension">
    Install [PalanK Browser Relay](https://chrome.google.com/webstore/detail/palank-browser-relay) from Chrome Web Store.
  </Step>

  <Step title="Pin to Toolbar">
    Click the puzzle icon in Chrome toolbar, then pin PalanK Browser Relay for easy access.
  </Step>
</Steps>

<Note>
  The extension only activates when you click its icon. Your browsing is never monitored passively.
</Note>

## Step 3: Connect Your Browser

<Steps>
  <Step title="Launch PalanK">
    Open PalanK Agent on your desktop. Wait for the app to fully load.
  </Step>

  <Step title="Open a Tab">
    Navigate to any webpage you want to automate in Chrome.
  </Step>

  <Step title="Activate Extension">
    Click the PalanK Browser Relay icon in Chrome toolbar. The badge will show "ON" when connected.
  </Step>
</Steps>

<Check>
  When successfully connected, you'll see:

  * Green "ON" badge on the extension icon
  * "Browser connected" status in PalanK app
</Check>

## Step 4: Start Using AI

Now you can control your browser with natural language!

<CodeGroup>
  ```text Example Commands theme={null}
  "Go to google.com and search for weather"

  "Click the first search result"

  "Fill the email field with test@example.com"

  "Take a screenshot of this page"

  "Scroll down and find the pricing section"
  ```
</CodeGroup>

## Troubleshooting

<AccordionGroup>
  <Accordion icon="circle-exclamation" title="Extension shows red ! badge">
    The relay server is not reachable. Make sure PalanK Desktop app is running, then click the extension icon again.
  </Accordion>

  <Accordion icon="plug" title="Can't connect to browser">
    1. Check if PalanK app is fully loaded
    2. Try clicking the extension icon to reconnect
    3. Refresh the webpage and try again
  </Accordion>

  <Accordion icon="shield" title="Permission denied">
    Some pages (chrome://, Chrome Web Store) cannot be controlled for security reasons. Try a regular webpage.
  </Accordion>
</AccordionGroup>

## Next Steps

<CardGroup>
  <Card title="Browser Control" icon="mouse-pointer" href="/features/browser-control">
    Learn all browser automation capabilities
  </Card>

  <Card title="AI Assistant" icon="robot" href="/features/ai-assistant">
    Master AI command patterns
  </Card>
</CardGroup>