ChatGPT Skills: What They Are and How to Add Live Web Access

New to TinyFish? Get started free and give ChatGPT live web access. TinySearch and TinyFetch cost nothing, and new accounts start with $8 in Wallet funds. From the MCP docs: a TinyResearch run costs $2 (Deep) or $3 (Max) when it completes, and TinySet charges $0.10 for each complete row it adds.

TL;DR

ChatGPT skills are saved, reusable workflows. Each skill is a folder with a SKILL.md file: a short name and description that tell ChatGPT when the skill is relevant, plus step-by-step instructions it follows when it is. You can add scripts, templates and reference files, and ChatGPT only loads the full instructions when a task actually needs them.

A skill is the recipe, not the kitchen. It tells ChatGPT how to do a job, but it doesn't give ChatGPT new abilities on its own. If your workflow depends on current information from the web (today's prices, this week's news, what a page says right now), pair the skill with a tool that can reach the live web.

In this guide I'll explain what ChatGPT skills are, how SKILL.md files work, how skills differ from prompts, plugins, apps, MCP servers and custom GPTs, and then build a real skill that checks competitor pricing using TinyFish for search, page reading and browser work. I'll also show how the same plugin handles bigger jobs a skill might hand off: cited research reports, tables built from the web, and pages watched on a schedule.

Disclosure: I work at TinyFish, which makes the web tools used in the walkthrough. Everything about how skills work comes from OpenAI's own documentation, linked throughout.

What are ChatGPT skills?

OpenAI describes a skill as "a reusable, shareable workflow that tells ChatGPT how to do a specific task." Instead of pasting the same long prompt into every chat, you write the process down once, and ChatGPT applies it whenever that task comes up (OpenAI Academy).

According to the OpenAI Help Center, a skill can include instructions, examples and code. Once a skill is installed, ChatGPT can use one or more skills automatically when they're helpful, or you can call one yourself by typing @ and picking it.

A skill usually has three parts:

• A name and description. These tell ChatGPT what the skill is for and when to use it.
• Workflow instructions. The step-by-step process, written in a file called SKILL.md.
• Resources. Anything the workflow depends on: templates, examples, brand guidelines, schemas, scripts or tool access.

Good candidates for a skill are tasks you repeat, where getting a good result depends on following the same steps every time: a weekly report, a standard email format, a research checklist, a review process.

Who can use skills in ChatGPT?

Availability depends on your plan and on which part of ChatGPT you use. The Help Center says skills are available to eligible ChatGPT Business, Enterprise, Healthcare and Edu users, subject to workspace settings. OpenAI's skills developer docs add that standalone skills are available in the ChatGPT desktop app, Codex CLI and the IDE extension, while skills bundled inside plugins also work in Chat and Work across ChatGPT on the web, desktop and mobile.

To find yours, open Plugins in the sidebar and select the Skills tab. Eligible accounts come with one skill by default, called skill-creator, which ChatGPT uses whenever you ask it to create or change a skill.

How SKILL.md files work

Every skill is a folder with one required file, SKILL.md, plus optional extras. This is the layout from OpenAI's docs:

my-skill/
  SKILL.md          Required: instructions + metadata
  scripts/          Optional: executable code
  references/       Optional: documentation
  assets/           Optional: templates, resources
  agents/
    openai.yaml     Optional: appearance and dependencies

SKILL.md is a plain Markdown file that starts with a small block of settings, called frontmatter, between two lines of three dashes. Two fields are required:

---
name: skill-name
description: Explain exactly when this skill should and should not trigger.
---

Skill instructions for ChatGPT or Codex to follow.

The open Agent Skills specification sets the rules for those fields:

• name: up to 64 characters, lowercase letters, numbers and hyphens only, and it must match the folder name.
• description: up to 1,024 characters, describing both what the skill does and when to use it.
• Optional fields: license, compatibility (environment requirements such as network access), metadata, and an experimental allowed-tools list.

Everything after the frontmatter is the instructions, in whatever form helps the agent do the job: numbered steps, examples of inputs and outputs, edge cases, the exact output format.

Why skills load in stages

Skills are designed to be cheap to keep around. OpenAI calls this progressive disclosure: ChatGPT starts with only each skill's name and description, then loads the full SKILL.md instructions when it decides to use that skill (OpenAI docs).

The Agent Skills spec breaks it into three levels:

1. Metadata (about 100 tokens): the name and description, loaded for every installed skill.
2. Instructions (under 5,000 tokens recommended): the full SKILL.md body, loaded when the skill is activated.
3. Resources (as needed): files in scripts/, references/ or assets/, loaded only when required.

Two practical consequences:

• The description is the trigger. ChatGPT decides whether to use a skill largely from its description, so OpenAI recommends putting the key use case and trigger words up front.
• Keep SKILL.md short. The spec recommends staying under 500 lines and moving detailed reference material into separate files.

If you want to know why this matters for cost and quality, our explainer on agentic context engineering goes deeper into keeping an agent's context window lean.

Skills are an open standard

SKILL.md isn't a ChatGPT-only format. OpenAI says its skills build on the open agent skills standard, and the standard's own site says the format "was originally developed by Anthropic, released as an open standard, and has been adopted by a growing number of agent products" (agentskills.io).

In practice that means a well-written skill is portable: the same folder can work in ChatGPT, Codex, Claude and other agent tools that support the format. Product-specific extras, such as the agents/openai.yaml file, only matter in the product that reads them.

Skills vs prompts, plugins, apps, MCP servers and custom GPTs

This is where most people get confused, partly because the names have changed over the years. Here is how the pieces fit together in ChatGPT today.

Skills vs prompts

A prompt lives in one conversation. A skill is the same knowledge saved as a reusable file that ChatGPT can pick up automatically, share with teammates, and improve over time. If you find yourself pasting the same template again and again, that's a skill waiting to be written.

Skills vs ChatGPT plugins

The word "plugin" has meant two different things:

• The original ChatGPT plugins (2023 to 2024). These were shut down. New plugin installs and new plugin conversations stopped on March 19, 2024, and existing plugin conversations ended on April 9, 2024 (OpenAI community announcement).
• Plugins today. The name came back in 2026 as the way ChatGPT and Codex package and distribute capabilities. OpenAI's plugins docs say a plugin can contain skills, MCP servers, browser extensions and hooks, and ChatGPT and Codex share one universal plugin directory.

So a skill is the authoring format for a workflow, and a plugin is how you distribute it. OpenAI's own advice is to "use skills to design the workflow itself, then package it as a plugin when you want other people to install it." For a tour of the plugins worth installing, see our guide to the best ChatGPT plugins.

Skills vs apps and MCP servers

Apps connect ChatGPT to services you already use, so it can find, summarize or act on information there (Help Center). Many of them are built on MCP, the Model Context Protocol, a standard way for a service to expose tools that an AI assistant can call.

The difference is simple:

• An app or MCP server gives ChatGPT new abilities: search this, read that, click here.
• A skill tells ChatGPT how and when to use those abilities for a particular job.

They work best together. A skill on its own can describe a perfect research process but can't fetch a single web page. An MCP server on its own can fetch pages but has no idea what your research process is. Put them together and you get a workflow that runs the same way every time, on current data.

Skills vs custom GPTs

Custom GPTs bundled instructions, knowledge files and actions into a shareable assistant. OpenAI is now retiring them. The Custom GPT retirement FAQ says custom GPTs are scheduled to retire on Dec 11, 2026 (Feb 11, 2027 for FedRAMP workspaces and some Enterprise workspaces with an approved deferral).

When you migrate a GPT, its instructions become a skill inside a new plugin, its knowledge files become reference files, and its connected apps are added as apps. One catch: custom actions don't transfer. If your GPT used an action to call another service, you'll need a replacement app, or a custom MCP server, before the deadline.

If you built a GPT that looked things up on the web through an action, this is the moment to rebuild it as a skill paired with a proper web tool, which is exactly what the walkthrough below does.

Why skills need live web access

Most useful workflows touch information that changes: prices, availability, news, docs, job postings, policies. A skill can't know any of that from its own instructions. It needs a tool that can reach the web at the moment the skill runs.

ChatGPT has its own web search, and for a quick question that's often enough. Workflows usually need more control than a search box:

• Reading specific pages in full. Not a summary of search results, but the actual content of the pricing page or docs page you care about.
• Pages that need JavaScript. Many modern sites only show their content after scripts run.
• Interactive sites. Prices behind a monthly/annual toggle, results behind a form, content several clicks deep.
• Repeatability. The same sources, read the same way, every time the skill runs.

That's the gap TinyFish fills. TinyFish is one API that gives agents the live web, with one account and one key behind it:

• TinySearch returns ranked web results as structured data, so the skill can find the right pages.
• TinyFetch reads any URL in a real browser, including JavaScript-heavy pages, and returns clean Markdown, HTML or JSON.
• TinyAgent completes multi-step tasks on a website from a plain-language goal: navigating, clicking, filling forms and extracting data.
• TinyBrowser gives you a remote browser session for direct control with Playwright or similar tools.
• TinyResearch runs deep research: it searches, reads and synthesizes many sources into a cited report.
• TinySet builds a table from one sentence: describe the rows and columns you want, and it fills each row from the web with sources.
• TinyMonitor watches a page or a topic on a schedule and tells you when something changes.

On pricing (from tinyfish.ai/pricing): TinySearch and TinyFetch are free, at up to 30 searches a minute and 500 an hour, and up to 150 URLs a minute and 1,000 a day. TinyAgent costs $0.016 per step and TinyBrowser $0.002 per browser-minute, drawn from your Wallet, and new accounts start with $8 in Wallet funds.

Walkthrough: build a ChatGPT skill that checks competitor pricing

Let's build something real: a skill that checks competitors' current pricing pages and returns a comparison table with sources. It's a good example because the answer changes constantly, and the information often sits behind toggles and JavaScript.

Step 1: Give ChatGPT web tools with the TinyFish plugin

The skill will tell ChatGPT to use TinyFish, so install that first. From the TinyFish docs:

1. Open the official TinyFish plugin on chatgpt.com. You can also search for TinyFish under Plugins.
2. Select Install plugin.
3. Complete the sign-in with your TinyFish account when prompted. There's no API key to paste.

The plugin bundles TinyFish's tools with its own skills and safety rules. If you'd rather add TinyFish as a custom MCP connector, the docs give this server URL, and ChatGPT will ask you to sign in:

https://agent.tinyfish.ai/mcp/chatgpt

Once connected, ChatGPT can call TinyFish tools, including search (web search), fetch_content (read up to 10 URLs per request), run_web_automation (multi-step browser tasks), start_deep_research (cited research reports), create_dataset (tables filled from the web) and create_monitor (scheduled watches on a page or topic). The full list is in the MCP integration docs.

Step 2: Write the SKILL.md

Here's the full skill. Notice that the description says both what the skill does and when to use it, and that the instructions name the lightest tool first and only escalate when needed.

---
name: competitor-pricing-check
description: Checks competitors' current public pricing pages and returns a comparison table with plan names, prices, billing period, key limits and source links. Use when the user asks to compare pricing, check what competitors charge, or see if a competitor's pricing has changed.
---

# Competitor pricing check

## Inputs
- A list of competitors (company names or pricing page URLs).
- Optional: the user's own product and plan, for comparison.
- Optional: a previous pricing table, to spot changes.

## Steps
1. For each competitor without a URL, use TinyFish search to find the official pricing page. Prefer the company's own domain. Never use review sites or resellers as the source.
2. Read each pricing page with TinyFish fetch_content in markdown format. Fetch up to 10 URLs per call.
3. If a page has no prices in the fetched content, or prices sit behind a monthly/annual toggle or a region selector, use TinyFish run_web_automation on that URL with the goal: "Extract every plan name, price, billing period and the top 3 limits for each plan. Return JSON. Do not sign up or log in."
4. Normalize prices to per-month in the page's currency. Note when a price is annual-only or "contact sales".
5. If a previous table was provided, mark anything that changed.

## Output
A Markdown table with these columns: Competitor | Plan | Price | Billing | Key limits | Source URL.
Below the table:
- "Checked on" with today's date.
- Up to 3 bullet points on notable differences.
- Any competitor whose pricing could not be found, and why.

## Rules
- Only report prices that appear on the page. If a price is not shown, write "not listed". Never estimate.
- Always include the source URL for every row.
- Do not create accounts, log in, or submit any forms.

A few choices worth copying in your own skills:

• Explicit inputs and output. The model knows exactly what to ask for and what "done" looks like.
• Search, then fetch, then automate. Reading a page with TinyFetch is fast and free. The skill only reaches for TinyAgent when the page needs interaction.
• Guardrails. "Never estimate" and "always include the source" stop the most common failure in pricing research: confident made-up numbers.

Step 3: Add the skill to ChatGPT

You have three options, all under Plugins, then the Skills tab (Help Center):

• Create with chat. Select Create, then Create with chat, and paste the SKILL.md above. Or simply ask ChatGPT to "build me a skill" and let skill-creator draft it, then review it.
• Create with editor. Select Create, then Create with editor, and paste the file in.
• Upload. Put SKILL.md in a folder named competitor-pricing-check (the folder name must match the skill's name), then select Create and Upload from your computer.

Uploaded skills are scanned before they become available. Some may be marked Needs Review or Blocked, and OpenAI recommends reviewing any skill from an outside source before you install it.

Step 4: Run it

Start a new chat and either call the skill directly with @competitor-pricing-check, or just describe the task:

Compare current pricing for Linear, Jira and Asana for a 10-person team.

Because the request matches the skill's description, ChatGPT can pick the skill up automatically. It then searches for each pricing page, reads them, switches to a browser run only where a page needs clicking, and returns the table with a source link on every row.

Step 5: Go further with TinySet, TinyMonitor and TinyResearch

The same plugin covers the jobs around the skill, so you can add a line or two to the instructions instead of building something new:

• Build the competitor list with TinySet. Instead of naming competitors yourself, ask for a table first, for example "Project management tools for small teams, with their pricing page URL and cheapest paid plan". TinySet fills each row from the web with sources, and the skill can then check every pricing page in the table.
• Keep watch with TinyMonitor. Once the table is right, ask ChatGPT to create a monitor on each pricing page, for example every Monday at 9 AM. You get told when a page changes, instead of re-running the skill to find out.
• Go deep with TinyResearch. When the question is bigger than prices, such as how each competitor positions its plans or what customers say about them, a TinyResearch run reads many sources and returns a cited report. Runs take several minutes, so the skill should start one only when you ask for that depth.

A simple rule for the skill's instructions: search and fetch for quick facts, TinySet for a list of many things with the same fields, TinyMonitor for anything you want checked again, TinyResearch for a cited report, and TinyAgent only when a page needs clicking.

Optional: the same skill in Codex or a terminal agent

In tools that let skills run scripts, such as Codex or the ChatGPT desktop app, you can call TinyFish from the command line instead of through the plugin. The TinyFish CLI docs cover setup:

npm install -g @tiny-fish/cli@latest
tinyfish auth login

Then the skill's steps can use commands like these:

# Find the pricing page
tinyfish search query "Asana pricing"

# Read it as clean Markdown
tinyfish fetch content get --format markdown "https://asana.com/pricing"

# Only if the page needs clicking
tinyfish agent run --url "https://asana.com/pricing" "Switch to monthly billing and extract every plan name and price. Return JSON."

Codex picks up repository skills from a .agents/skills folder, and you can create one with $skill-creator (OpenAI docs). The CLI writes results to the filesystem rather than piping them through the model's context, which keeps runs lean. We wrote about why that matters in we shipped an MCP server, then we shipped a CLI.

If you'd rather not write the web-access part yourself, our open-source use-tinyfish skill already teaches an agent when to search, fetch, run the agent or open a browser. Drop it next to your own skills and let your workflow skill focus on the job itself.

More skill ideas that need live web access

Once the pattern clicks, plenty of everyday workflows become skills:

• Daily news brief. Search for news on your topics from the last 24 hours, fetch the top articles, and summarize them in a fixed format with links.
• Docs-checker. Before answering a technical question, fetch the latest official docs page instead of relying on what the model remembers.
• Job and internship radar. Search careers pages for matching roles and return a ranked list. A student built exactly this with TinyFish: read the Openings build log.
• Form filler. Take details from the chat and complete a web form, stopping before submit for your review. We walked through a version of this in create a Google Form with ChatGPT using TinyFish.
• Lead research. Search for a company, fetch its about and pricing pages, and fill a standard one-page profile.
• Prospect list builder. Turn a description like "independent coffee roasters in Melbourne with an online shop" into a sourced table with TinySet, then fill a standard outreach note for each row.
• Change tracker. Set a TinyMonitor on a policy page, a docs page or a competitor's changelog, and summarize what changed each week.
• Market brief. Start a TinyResearch run on a market or topic and turn the cited report into a one-page brief in your house format.

Skill ideas by who you are

Skills aren't only for developers. Anyone who repeats the same web task every week can turn it into one:

• Startups and founders. Competitor pricing, investor and accelerator research, and weekly market scans. See 10 ChatGPT workflows for startups and our guide to competitor price tracking.
• Marketers and content teams. Trend briefs, SERP checks before writing, and tracking what competitors publish. More in AI for content marketing.
• Sales and growth teams. Prospect lists built with TinySet, account research before a call, and alerts when a target company changes its pricing or careers page.
• Small businesses. Supplier and price checks, finding local events or listings to apply to, and filling the same web forms every month.
• Researchers and analysts. Cited TinyResearch reports, literature and news scans, and monitors on the pages you cite.
• Students. Internship radars, study-room finders and fact-checkers. See what students built in TinyFish in ChatGPT: student use cases.

For more plugins that pair well with skills, see our roundup of the best ChatGPT plugins.

Tips for writing skills that work

These come from OpenAI's best practices, the Agent Skills guidance, and what we've seen work:

• One job per skill. OpenAI recommends small building blocks you can mix and match rather than one giant skill.
• Write the description for the trigger. Lead with the use case and the words people actually type, such as "compare pricing", "what competitors charge".
• Say what "done" looks like. Give the exact output format and a final checklist.
• Prefer instructions over scripts. Add code only when you need deterministic behavior or an external tool.
• Name the tool and the fallback. "Use search, then fetch, and only use browser automation if the page needs interaction" gives faster, cheaper and more predictable runs.
• Ban guessing. For anything factual, tell the skill to say "not found" rather than invent a value, and to cite every source.
• Test the trigger. Try a few natural phrasings and check that the right skill gets picked up.

Common mistakes

• Expecting the skill to know current facts. A skill only knows what's in its files. Anything time-sensitive needs a live web tool.
• Vague descriptions. "Helps with research" will trigger at the wrong times, or not at all.
• Everything in one file. Long SKILL.md files cost context every time they load. Move reference material into references/.
• Installing skills you haven't read. Skills can include code. Review anything from an outside source before you upload it.
• Leaving custom GPT actions until December. Actions don't migrate automatically, so rebuild them with an app or MCP server well before the Dec 11, 2026 retirement.

Give your ChatGPT skills the live web

Skills are the simplest way to make ChatGPT do a job your way, every time. The moment that job depends on what's true today, pair the skill with a web tool. Install the TinyFish plugin to give ChatGPT live search, page reading and browser actions, or use the CLI and API in your own scripts. TinySearch and TinyFetch are free, so you can build and test your first web-aware skill without spending anything.

Ready to try it? Sign up for TinyFish, install the ChatGPT plugin, and run your first web-aware skill in minutes.