How to give Claude access to real-time web data

Claude has no live data of its own. It answers from a training corpus that was frozen on a fixed date, so today's prices, this week's posts and a follower count from an hour ago are not in it at all. There are three ways to fix that, and they take between ten seconds and two minutes: switch on built-in web search, connect an MCP server, or install a skill that calls an HTTP API. This guide sets up all three, then runs one real call end to end.

Why does Claude not know what happened today?

Because a model's knowledge is a snapshot, not a feed. Training ends on a cutoff date, the weights are frozen, and every conversation afterwards reads from that same frozen copy. Nothing you type updates it, and the distance between the cutoff and today grows by one day every day.

There is a second gap that matters more in practice, and it has nothing to do with recency. Even for things that existed long before the cutoff, a model holds compressed text rather than records. It has read plenty about TikTok, so it can describe how the app works. It cannot tell you how many times one specific video was watched, what the top comment says, or what a product sells for right now, because those are rows in somebody's database and were never sentences on a page.

So "give Claude real-time web data" is really two asks at once: fresh, and structured. A tool that hands back a paragraph solves the first. A tool that hands back typed rows solves both, and rows are what you need the moment the answer has to be sorted, counted or written to a file.

Option 1: built-in web search, and where it stops

Built-in web search is the fastest fix and it genuinely covers a share of the questions people ask. Turn it on in settings, ask, and Claude runs a search, opens a few results and answers with citations. In Claude Code the same capability is the web search and fetch tools, available without any configuration. Setup time is about ten seconds.

The limits show up the moment the job is repeatable. Search reaches public pages a crawler can render, so anything behind a login, an app or an API is invisible to it: TikTok view counts, Instagram follower numbers, Amazon review text, LinkedIn job listings, Google Maps reviews. What comes back is prose your agent has to re-parse rather than fields it can sort. You cannot ask for 200 rows. And you have no visibility into how many searches ran or what they cost, because they are bundled into the plan.

Option 2: connect an MCP server

An MCP server is the standard way to hand an agent tools it did not ship with. You add one URL, approve one sign-in, and the tools that server exposes show up inside Claude with names, descriptions and JSON schemas the model reads at runtime. Nothing installs and nothing runs on your machine, and the same server works in Claude, Claude Code, Cursor and anything else that speaks the protocol. If the protocol itself is new, the MCP explainer covers it in full.

Add it to Claude as a custom connector

1. Open settings, then connectors.
2. Choose add custom connector.
3. Paste the connector URL and save.
4. Start a chat, open the tools menu, and every tool the server exposes is listed there with a switch of its own.

https://mcp.usegoro.ai/mcp

Note the /mcp path. The bare host is not the connector URL and pasting it produces an authorization failure rather than a connection. The first tool call opens Goro's authorize screen in the browser; approve it there and the connection stays. Custom connectors are a paid-plan feature, and on team plans an admin can install one for the whole workspace so nobody repeats the setup.

Add it to Claude Code

A .mcp.json file in the project root is the version to prefer, because it is checked into the repo and every teammate gets the same tools on their next run.

{
  "mcpServers": {
    "goro": {
      "type": "http",
      "url": "https://mcp.usegoro.ai/mcp"
    }
  }
}

Or skip the file and let the CLI write it:

$ claude mcp add --transport http goro https://mcp.usegoro.ai/mcp

Run /mcp inside a session to see connection status. A server that connects but lists no tools has almost always not finished its sign-in.

Option 3: skills, for agents that are not MCP clients

A skill is an instruction file the agent reads once and then follows. No connector, no OAuth round trip: you paste a URL into the chat, the agent reads it, stores an API key where its host keeps secrets, and calls the HTTP API directly from then on. It works in anything that can fetch a page, which includes hosts with no MCP client at all.

set up https://usegoro.ai/SKILL.md

The file at https://usegoro.ai/SKILL.md is the whole surface in one document: how discovery works, what each price shape means, the run and poll loop, and the specific traps that waste money, such as a result count that applies per target rather than per call. Same catalog, same prices, same balance as the connector. The only difference is how the agent is wired.

Which of the three should you pick?

Use built-in search for one-off questions about public pages, an MCP connector for anything repeatable, and a skill when the host has no MCP client or you want the agent to hold its own key. They are not exclusive: search stays on while a connector is added, and the model picks whichever fits the question.

What does the whole loop look like end to end?

Four steps, roughly a minute: discover a tool, inspect its schema, run it, collect the rows. Below is a real question run through a connected server, asking what TikTok has been saying about protein coffee this week. The calls are the ones the agent makes on its own once the connector is added.

1. Discover

Discovery is a plain-language query against the catalog. Name the platform and the object you want. It comes back with candidates, each carrying its price and a sample input, so the model can choose without reading any documentation.

{
  "query": "recent tiktok posts for a keyword",
  "limit": 5
}

{
  "items": [
    {
      "slug": "tiktok.api",
      "name": "TikTok",
      "category": "social",
      "price": {
        "type": "usage_based",
        "per_unit_usd": "$0.0060",
        "unit_label": "request",
        "min_usd": "$0.0020",
        "max_usd": "$2.00",
        "billed_on_actual_usage": true
      },
      "sample_input": { "searchPosts_keyword": "<keyword>" }
    }
  ]
}

2. Inspect

Inspect returns the full JSON Schema plus a sample of the output. It is worth the round trip. Most data tools pass your input to the upstream provider verbatim, so a misspelled or invented field name is accepted, quietly ignored, and still billed. Required fields and types are enforced; unknown ones are not.

3. Run

One call, with the fields the schema named. Here that is a keyword, a result count and a recency filter set to the last seven days.

{
  "slug": "tiktok.api",
  "input": {
    "searchPosts_keyword": "protein coffee",
    "searchPosts_count": 30,
    "searchPosts_publishTime": 7
  }
}

Anything that finishes inside about 25 seconds returns the rows inline. Slower work returns a run id instead, and you poll it every few seconds until the status is terminal.

4. Collect

{
  "run_id": "…",
  "status": "COMPLETED",
  "output_count": 30,
  "quoted_cost_usd": "$0.2400",
  "cost_usd": "$0.0060",
  "output": [ … ]
}

Two numbers doing two jobs. quoted_cost_usd is what was held on the balance while the run was in flight. cost_usd is what you were actually charged, and it is the one that matters: $0.0060 here, because the TikTok tool bills one flat request per section you fill in and this call filled exactly one. Rows are deleted 24 hours after a run finishes, and usually straight after your first successful fetch, so collect once and persist what you want to keep.

Swap the slug and the same four steps answer a different question. The Reddit toolreads posts and comments through Reddit's own API, web search runs a Google query and returns ranked organic results, and the X search tool pulls recent posts by keyword or advanced query. Chain three of them behind one prompt and you have the loop described in social listening with AI agents.

What does real-time data cost?

Signing up and browsing the catalog are free. Running a tool needs a plan, and from there every call is priced on its own from one balance: the agent sees the price before it runs, the charge settles against that balance, and a run that fails or returns nothing releases its hold and charges nothing. The two plans on the pricing page carry the same catalog, nothing is locked behind a tier. Current rates for the tools in this article:

• tiktok.api: $0.0060 per request, and a request is one section of the call, whatever number of results it returns.
• reddit.api: $0.0090 per result, where a result is a post, a comment, a community or a user.
• web.search: $0.0075 per results page, about ten organic results each.
• twitter.search: $0.0012 per result.
• Every one of them has a $0.0020 minimum per call and a hard ceiling per call, and all of them bill on actual usage rather than on what you asked for.

Put those together. A morning brief that runs one TikTok keyword search, pulls 25 Reddit items and reads two pages of Google results costs about $0.25 per run at those rates, which is roughly $7 a month if it runs every day. A quiet day that returns eight Reddit rows instead of 25 costs less, because the charge follows the rows that actually came back.

The tradeoff is worth stating plainly. A gateway is an extra hop, and a first-party server written by the vendor of the thing you are calling will always know that thing better than a catalog does. What you get back is one connection instead of twenty accounts, and a bill that follows the calls your agent actually makes. Prices for all 62 tools are listed on the tools pages, no account needed to read them.