Research to Sheets

Research websites, extract structured findings, and save clean rows into Google Sheets. Use when users want web research organized into a spreadsheet — compe...

installs

stars

karma

SkillRank score ↗

8.3/ 10

evaluated by implexa, claude-haiku-4-5 · 2026-06-11

research-to-sheets chains web research with google sheets writes through clawlink, normalizing findings into structured rows before appending. covers setup, discovery, execution, and confirmation workflows with explicit error handling.

structure

9.0

trigger phrases

9.0

procedure

9.0

edge cases

7.0

documentation

8.0

strengths

view original SKILL.md from clawhubclick to expand

---
name: research-to-sheets
description: Research websites, extract structured findings, and save clean rows into Google Sheets. Use when users want web research organized into a spreadsheet — competitor lists, pricing data, contact lists, or any structured table from the web.
---

# Research to Sheets

![Research to Sheets](https://raw.githubusercontent.com/ClawLink-HQ/clawlink/main/public/images/brand-logos/google-sheets.svg)

Research websites, extract structured findings, and save clean rows into Google Sheets. Use when users want web research organized into a spreadsheet — competitor lists, pricing data, contact lists, or any structured table from the web.

This skill uses [ClawLink](https://claw-link.dev/?utm_source=clawhub&utm_medium=referral&utm_content=research-to-sheets) for the Google Sheets step, so the user does not need manual Google Sheets API setup.

### Setup in 3 Steps

## How It Works

```
┌─────────────────┐ ┌──────────────┐ ┌──────────────────┐
│ OpenClaw │────▶│ ClawLink │────▶│ Google Sheets │
│ (User Chat) │ │ (OAuth) │ │ (Sheets API) │
└─────────────────┘ └──────────────┘ └──────────────────┘
│ │ │
│ 1. Install Plugin │ │
│ 2. Pair Device │ │
│ 3. Connect Sheets │ │
│ │ 4. Secure Token │
│ │ 5. Proxy Requests │
│ │ │
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ SKILL │ │ Dashboard│ │ Google │
│ File │ │ Auth │ │ Sheets │
└──────────┘ └──────────┘ └──────────┘
```

## Install

Install the verified ClawLink plugin from ClawHub. After the user confirms, complete the full setup so ClawLink tools are visible in the next OpenClaw chat.

```bash
openclaw plugins install clawhub:clawlink-plugin
openclaw config set tools.alsoAllow '["clawlink-plugin"]' --strict-json
openclaw gateway restart
```

Then tell the user: "OpenClaw has been restarted. Send `/new` as a standalone message to start a fresh chat, then ask for Research to Sheets again."

## Quick Start

```bash
# List available Google Sheets tools
clawlink_list_tools --integration google-sheets

# Search for append rows tool
clawlink_search_tools --query "append rows" --integration google-sheets
```

## Good Trigger Phrases

- "Research these companies and save the results to my sheet"
- "Find competitors and put them into Google Sheets"
- "Collect pricing data from these sites and write it to a spreadsheet"
- "Scrape these pages and organize the findings into rows"
- "Build me a lead list in Google Sheets"

## Workflow

### 1. Clarify the table before doing work

Ask for:
- the research goal
- the columns the user wants
- the destination spreadsheet or sheet tab if they already have one
- the number of rows or scope to gather

If the output structure is unclear, propose a simple column set before collecting data.

### 2. Gather information from the web

Use whatever research capability is available in the current chat to gather raw findings.

Examples:
- company name, website, and description
- pricing tier names and prices
- contact names, roles, and emails
- article titles, URLs, and summaries
- product names, categories, and features

Do not write messy partial rows into Google Sheets if the structure is still changing.

### 3. Normalize the findings into rows

Before writing anything:
- remove duplicates
- make sure each row matches the same column structure
- note missing values explicitly instead of guessing
- keep URLs, emails, and numbers in clean machine-friendly formats

Show the user a short preview of 3-5 rows when the data matters.

### 4. Discover the live Google Sheets tools

1. Call `clawlink_list_integrations` to confirm Google Sheets is connected.
2. Call `clawlink_list_tools` with integration `google-sheets`.
3. If the exact write tool is unclear, call `clawlink_search_tools` with a short query such as `append rows`, `create spreadsheet`, or `update cells`.
4. Call `clawlink_describe_tool` before using an unfamiliar tool or any write.
5. Use the returned schema and guidance as the source of truth.

### 5. Preview and confirm writes

For any write, create, overwrite, append, or bulk update action:

1. Call `clawlink_preview_tool` first when available.
2. Show the user what sheet or range will be changed.
3. Confirm before writing.
4. Execute with `clawlink_call_tool`.

### 6. Finish cleanly

After writing:
- summarize what was saved
- mention the sheet or spreadsheet name if known
- note any skipped rows or missing values
- offer a next step such as sorting, deduplicating, or adding formulas

## Good Workflow Behavior

- Prefer creating a clear schema before collecting many rows.
- Prefer appending rows over overwriting existing data unless the user explicitly wants replacement.
- Keep row values short and structured.
- If the user asks for a large scrape, suggest a smaller first batch to verify the format.
- If a sheet already exists, inspect it before writing so you do not break the layout.

## Rules

- Always use ClawLink tools for Google Sheets writes. Do not ask the user for separate Sheets credentials.
- Do not invent Google Sheets tool names or schemas. Use the live ClawLink catalog in the current turn.
- Ask for confirmation before creating spreadsheets, appending rows, overwriting cells, or editing many records.
- Do not fabricate missing research data just to complete a table.
- If Google Sheets is not connected, direct the user to https://claw-link.dev/dashboard?add=google-sheets.

## Example Prompts

- Research25 AI agent startups and save name, website, category, and one-line description into Google Sheets.
- Visit these competitor pricing pages, extract plan names and monthly prices, and write them into a spreadsheet.
- Find coffee shops in this city and save name, website, phone, and address to my sheet.
- Research LinkedIn profiles from this list of founders and save the results into Google Sheets.

## Discovery Workflow

1. Call `clawlink_list_integrations` to confirm Google Sheets is connected.
2. Call `clawlink_list_tools --integration google-sheets` to see the live catalog.
3. Treat the returned list as the source of truth. Do not guess or assume what tools exist.
4. If the user describes a capability but the exact tool is unclear, call `clawlink_search_tools` with a short query and integration `google-sheets`.
5. If no Google Sheets tools appear, direct the user to https://claw-link.dev/dashboard?add=google-sheets.

## Execution Workflow

```
┌─────────────────────────────────────────────────────────────┐
│ READ OPERATIONS (Safe) │
│ list → get → search → describe → call │
│ │
│ Example: List sheets → Inspect existing → Show structure │
└─────────────────────────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────┐
│ WRITE OPERATIONS (Require Confirmation) │
│ list → get → describe → preview → confirm → call │
│ │
│ Example: Describe tool → Preview changes → User approves │
│ → Execute append │
└─────────────────────────────────────────────────────────────┘
```

1. For unfamiliar tools, ambiguous requests, or any write action, call `clawlink_describe_tool` first.
2. Use the returned guidance, schema, `whenToUse`, `askBefore`, `safeDefaults`, `examples`, and `followups` to shape the call.
3. Prefer read, list, search, and get operations before writes when that reduces ambiguity.
4. For writes or anything marked as requiring confirmation, call `clawlink_preview_tool` first.
5. Execute with `clawlink_call_tool`. Pass confirmation only after the preview matches the user's intent.
6. If the tool call fails, report the real error. Do not invent results or restate the failure as a missing capability unless the live catalog supports that conclusion.

## Notes

- This is a workflow skill — it chains web research with Google Sheets writes.
- Web research tools depend on what is available in the current chat session.
- Google Sheets writes go through ClawLink — no Sheets credentials needed.
- Always normalize data before writing — messy input creates messy spreadsheets.

## Error Handling

| Status / Error | Meaning |
|----------------|---------|
| Tool not found | The tool name does not exist in the current catalog. Verify with `clawlink_list_tools --integration google-sheets`. |
| Missing connection | Google Sheets is not connected. Direct the user to https://claw-link.dev/dashboard?add=google-sheets. |
| `SPREADSHEET_NOT_FOUND` | The spreadsheet ID or URL is invalid. |
| Write rejected | User did not confirm a write action. Always confirm before executing writes. |

### Troubleshooting: Tools Not Visible

1. Check that the ClawLink plugin is installed:
```bash
openclaw plugins list
```
2. If the plugin is installed but tools are missing, tell the user to send `/new` as a standalone message to reload the catalog.
3. If a fresh chat does not help, run:
```bash
openclaw config set tools.alsoAllow '["clawlink-plugin"]' --strict-json
openclaw gateway restart
```
4. After restart, tell the user to send `/new` again and retry.

### Troubleshooting: Invalid Tool Call

1. Ensure the integration slug is `google-sheets` for Google Sheets tools.
2. Use `clawlink_describe_tool` to verify parameter names and types before calling.
3. For write operations, always call `clawlink_preview_tool` first.

## Resources

- ClawLink: https://claw-link.dev/?utm_source=clawhub&utm_medium=referral&utm_content=research-to-sheets
- ClawLink Docs: https://docs.claw-link.dev/openclaw
- ClawLink Verification: https://claw-link.dev/verify
- Google Sheets API: https://developers.google.com/sheets/api

## Related Skills

- [Google Sheets](https://clawhub.ai/hith3sh/google-sheets-spreadsheets) — For full Google Sheets operations
- [Firecrawl](https://clawhub.ai/hith3sh/firecrawl-web-scraping) — For web research and scraping

---

![ClawLink Logo](https://raw.githubusercontent.com/ClawLink-HQ/clawlink/main/public/images/logo/link_logo_black_small.png)

don't have the plugin yet? install it then click "run inline in claude" again.

restructured into implexa's 6-component format, made decision logic explicit, documented clawlink oauth setup as inputs, added edge cases (rate limits, auth expiry, empty results, duplicates), clarified procedural steps with explicit inputs/outputs, kept original author's workflow and rules intact.

Research to Sheets

Research websites, extract structured findings, and save clean rows into Google Sheets. Use when you need to turn unstructured web data into a clean, organized table. Common triggers: competitor research, pricing benchmarks, lead lists, contact scrapes, or any structured data harvest from the web that belongs in a spreadsheet.

intent

This skill chains web research with Google Sheets writes via ClawLink, a proxy that handles OAuth so you don't need to manage Sheets credentials yourself. Use it whenever a user asks to research something on the web and land the findings in a spreadsheet. The skill prioritizes data quality: it normalizes raw findings, removes duplicates, confirms writes before executing them, and surfaces missing values explicitly instead of guessing.

inputs

ClawLink Setup (Required)

ClawLink plugin installed in OpenClaw (via openclaw plugins install clawhub:clawlink-plugin)
ClawLink dashboard accessible at https://claw-link.dev/dashboard
Google Sheets connected via ClawLink dashboard (user navigates to https://claw-link.dev/dashboard?add=google-sheets and completes OAuth)
OAuth token refreshed (ClawLink handles this automatically; expires every ~1 hour, resets on next API call)

User Context

research goal (e.g., "find 25 AI startups")
desired columns (e.g., "company name, website, category, description")
target spreadsheet (existing URL/ID, or create new)
scope/row count (e.g., "first 20 rows", "as many as you find")

Web Research Capability

current chat session must support web search, scraping, or similar research tools (varies by environment)

External Connections

Google Sheets API (accessed via ClawLink proxy; no direct auth needed)
ClawLink gateway (routes all Sheets calls through OAuth-secured proxy)

procedure

Step 1: Clarify the table schema before research

Input: user request (unstructured) Output: agreed column names, data types, row scope

Ask the user for the research goal in one sentence.
Ask what columns they want (e.g., company name, URL, price, contact email).
Ask if they have an existing spreadsheet or want a new one. If existing, ask for the sheet tab name.
Ask for row count or scope (e.g., "top 10", "all results", "first batch of 20").
Propose a simple column set if the user is uncertain. Show an example: "I'll capture: Name | Website | Category | 1-line Description. Sound good?"
Do not proceed to research until the schema is locked.

Step 2: Gather raw findings from the web

Input: research goal, agreed columns Output: raw data list (names, URLs, descriptions, etc., may have duplicates or inconsistencies)

Use available web research tools in the current chat (search, scrape, browse, etc.).
Collect fields that match the agreed columns. If the web source has extra fields, note them but focus on what was agreed.
Capture at least 3-5 rows worth of data before moving to Step 3 (do not write partial work into Sheets).
If web research fails (no results, rate limit, timeout), report the error and ask if the user wants to narrow the search or try different keywords.

Step 3: Normalize findings into clean rows

Input: raw findings (list of records with possible duplicates, missing fields, inconsistent formats) Output: normalized data (deduplicated, consistent schema, nulls explicit)

Remove exact duplicate rows (same values across all columns).
Verify each row has the same column structure (same number of fields in the same order).
For missing values, use empty string or explicit marker (e.g., "not found") instead of guessing or inferring.
Format URLs, emails, phone numbers, and prices consistently (e.g., all prices as numbers, no currency symbols; all emails lowercase).
Trim whitespace from all text fields.

Show the user a preview of 3-5 normalized rows. Example:

Company | Website | Category | Description
Anthropic | anthropic.com | AI/ML | AI safety and research
OpenAI | openai.com | AI/ML | LLM research and deployment

Ask: "Does this format look right?" Wait for confirmation.

Step 4: Discover live Google Sheets tools

Input: (none; query the ClawLink catalog) Output: list of available Sheets tools (append rows, create spreadsheet, etc.)

Call clawlink_list_integrations to confirm Google Sheets is available.
If Google Sheets does not appear, direct the user to https://claw-link.dev/dashboard?add=google-sheets and pause.
Call clawlink_list_tools --integration google-sheets to see all available Sheets tools.
If the exact tool is unclear (e.g., "should I use append_rows or write_rows?"), call clawlink_search_tools --query "append rows" --integration google-sheets.
Treat the returned catalog as the source of truth. Do not assume tool names or schemas.

Step 5: Describe the tool and preview the write

Input: tool name from Step 4, normalized data, target spreadsheet Output: preview of what will be written, confirmation from user

Call clawlink_describe_tool with the tool name (e.g., google_sheets_append_rows). Review the returned schema, parameters, and examples.
If the target spreadsheet already exists, optionally call a "get" or "list" tool first to inspect its current structure so you do not break the layout.
Call clawlink_preview_tool with the same parameters you plan to use (spreadsheet ID, sheet name, data rows). This shows the user what will change.
Show the user the preview. Ask: "Should I write these rows to [Spreadsheet Name], sheet [Tab Name]?" Wait for explicit yes/no.
If the user says no, return to Step 3 and ask what needs to change.

Step 6: Execute the write

Input: user confirmation from Step 5 Output: success or error response from ClawLink

Call clawlink_call_tool with the confirmed parameters.
If the call succeeds, report the number of rows written and the sheet name.
If the call fails:
- Report the actual error message (e.g., SPREADSHEET_NOT_FOUND, rate limit, auth expired).
- Do not invent results.
- Offer a next step (e.g., "Is the spreadsheet ID correct?", "Try again in a moment", "Check that Google Sheets is still connected").

Step 7: Summarize and offer next steps

Input: write result from Step 6 Output: user summary, next-step suggestions

Summarize what was saved: "Wrote 12 rows to [Spreadsheet Name], sheet [Tab Name]."
Call out any rows skipped or values left blank (e.g., "2 companies had no website listed").
Offer a follow-up: "Want me to sort by category?", "Should I add a formula for auto-numbering?", "Ready to research more rows?"
Do not claim the task is complete until the user confirms.

decision points

If the user has an existing spreadsheet:

Ask for the spreadsheet URL or ID.
Call a read/list tool first to inspect the current layout.
Confirm before appending so you do not break existing structure.
If appending to an existing sheet, ensure new rows match the existing column order.

If the user wants a new spreadsheet:

Confirm the spreadsheet name.
Call clawlink_search_tools with query "create spreadsheet" to find the right tool.
Describe the tool, then call clawlink_preview_tool to show the user the new sheet name before creating it.

If Google Sheets is not connected:

Do not attempt to call Sheets tools.
Direct the user to https://claw-link.dev/dashboard?add=google-sheets.
Tell the user to complete the OAuth flow, then return to the chat.
After the user reports connection is done, call clawlink_list_integrations again to verify.

If web research returns no results:

Ask the user if they want to refine keywords or search scope.
Offer to try alternative search terms.
Do not proceed to write empty rows into Sheets.

If research data is incomplete or inconsistent:

Do not guess or fabricate missing values.
Show the user the raw findings and ask: "Should I skip rows with missing [field], or do you want me to research those separately?"

If a Sheets tool call fails with rate limit or auth error:

Offer to retry in 30-60 seconds (rate limit) or direct the user to reconnect Google Sheets (auth expired).
Do not re-attempt immediately.

If the user asks to overwrite existing cells instead of appending:

Confirm explicitly: "This will replace existing data in [Range]. Are you sure?"
Only execute if the user says yes.
Never overwrite without confirmation.

output contract

Success state:

One or more rows written to a Google Sheet via ClawLink.
Target spreadsheet URL or ID known and accessible by the user.
Sheet tab name recorded.
Row count written confirmed (e.g., "12 rows appended").

Data format in sheet:

One row per record.
One column per agreed field (e.g., Company | Website | Category | Description).
No extra blank rows between data.
URLs, emails, phone numbers, and prices in consistent machine-friendly format (lowercase, no extra punctuation).
Missing values shown as empty string (blank cell) or explicit marker like "not found".

File location:

Google Sheet, accessible via URL like https://docs.google.com/spreadsheets/d/{SPREADSHEET_ID}/edit#gid={SHEET_ID}.
Sheet tab name visible in sheet tabs bar at bottom of screen.

Error state:

Tool call fails and actual error returned (e.g., SPREADSHEET_NOT_FOUND, network timeout, rate limit).
User did not confirm write action (write rejected, skill halted at Step 5).
Web research returned zero results (no data to write).

outcome signal

The user knows the skill worked when:

They see a confirmed preview before any write happens.
The skill reports "Wrote X rows to [Spreadsheet Name], sheet [Tab Name]."
They open the Google Sheet URL and the new rows appear in the correct tab.
The data is clean, deduplicated, and matches the agreed column structure.
No data is missing or guessed; missing fields are explicit (blank or marked).
The skill offers a next step (e.g., "Ready to add more rows?", "Want to sort by category?").

If the user opens the sheet and rows are missing, scrambled, or in the wrong tab, the skill did not work. The user should report the discrepancy so the skill can retry or investigate the Sheets tool error.

good workflow behavior

Lock the schema before researching. A clear column set prevents wasted research.
Prefer appending rows over overwriting unless the user explicitly asks to replace.
Normalize and preview before writing. Messy input creates messy sheets.
For large scrapes, suggest a small first batch (e.g., 10-20 rows) to verify format before going for 100+.
If a sheet already exists, inspect it first. Do not break the layout by appending misaligned rows.
Always confirm writes. Do not execute appends, creates, or overwrites without explicit user approval.
Use the live ClawLink catalog, not guessed tool names or schemas.

rules

Always use ClawLink tools for Google Sheets writes. Never ask the user for separate Sheets credentials or API keys.
Never invent tool names or schemas. Call clawlink_list_tools or clawlink_search_tools to find the exact tool.
Always ask for confirmation before creating spreadsheets, appending rows, overwriting cells, or editing many records.
Never fabricate research data to complete a table. Show missing values explicitly.
If Google Sheets is not connected, direct the user to https://claw-link.dev/dashboard?add=google-sheets. Do not attempt Sheets writes without connection.
Use clawlink_preview_tool for all writes. Show the user what will change before executing.

example prompts

"Research 25 AI agent startups and save name, website, category, and one-line description into Google Sheets."
"Visit these competitor pricing pages, extract plan names and monthly prices, and write them into a spreadsheet."
"Find coffee shops in this city and save name, website, phone, and address to my sheet."
"Research LinkedIn profiles from this list of founders and save the results into Google Sheets."
"Scrape these product pages and compile a table of product names, prices, and descriptions."

troubleshooting

Tools not visible in ClawLink catalog

Verify the plugin is installed: openclaw plugins list should show clawlink-plugin.
If installed but tools are missing, have the user send /new as a standalone message to reload the catalog.
If a fresh chat does not help, run: openclaw config set tools.alsoAllow '["clawlink-plugin"]' --strict-json and openclaw gateway restart.
After restart, user sends /new again and retries.

Google Sheets not connected

Direct the user to https://claw-link.dev/dashboard?add=google-sheets.
User completes the OAuth flow and approves OpenClaw/ClawLink.
Return to chat and call clawlink_list_integrations to confirm connection.

Invalid tool call or wrong parameter names

Call clawlink_describe_tool with the tool name to verify exact parameters and types.
Ensure the integration slug is google-sheets (not sheets, gsheets, etc.).
For write operations, always call clawlink_preview_tool first.

Write rejected (SPREADSHEET_NOT_FOUND, invalid range, etc.)

Verify the spreadsheet ID or URL is correct.
Confirm the sheet tab name exists.
Check that the user has write permission on the sheet.
Ask the user to provide the correct spreadsheet URL and retry.

Rate limit or auth token expired

If rate limit, wait 30-60 seconds and retry.
If auth error, direct the user to https://claw-link.dev/dashboard to refresh or reconnect Google Sheets.

resources

ClawLink: https://claw-link.dev
ClawLink Docs: https://docs.claw-link.dev/openclaw
ClawLink Verification: https://claw-link.dev/verify
Google Sheets API: https://developers.google.com/sheets/api

related skills

Google Sheets , For full Google Sheets operations beyond research writes.
Firecrawl , For web research and scraping at scale.