Build a Getty Images MCP Server for Agentic Creative & Editorial Content Search

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

On August 12, 2026, Getty Images launched an MCP Server that connects its creative and editorial content catalog to AI workflows and AI-powered products through a single integration. The announcement is the clearest signal yet that the licensed-content industry is building for the agent era: instead of forcing every AI product to build its own Getty integration, the company exposes its catalog over the Model Context Protocol, so any MCP-compatible agent — Claude Desktop, Cursor, a custom LangGraph fleet — can search, evaluate, and select licensed imagery with rights metadata attached. This guide builds a production-grade Python FastMCP server, getty-mcp, that wraps the Getty Images API into clean typed agent tools — creative search, editorial search, curated collections, and asset metadata — and wires it into Claude Desktop and LangGraph with the license awareness that makes agent-selected imagery legally usable. If you are building an agent surface around licensed content, the MCP directory is the reference map for the connector layer.

Why a gateway over the official MCP server

The official Getty MCP server is the fastest on-ramp: connect it, and an agent can search the catalog out of the box. A custom FastMCP gateway is the right call when you need any of these:

• License-aware filtering. The single most important difference between searching images and searching usable images. The gateway filters every result to commercially licensed assets by default, so an agent cannot return an editorial-only image for a product ad.
• A narrower, audited surface. The gateway exposes exactly the tools your content agents are approved to touch — search and metadata, not account administration or bulk download.
• Combined workflows in one call. A single search_creative call that returns licensed candidates with rights metadata, or a search-then-attach sequence inside a content pipeline, is painful to orchestrate against a raw API.
• Per-agent rate limits and keys. One key per agent or tenant means decommissioning a rogue agent means revoking a single key, not rotating a shared credential.

The launch is also a pattern moment: the licensed-content industry — stock imagery, editorial photography, news footage — is the perfect MCP use case because the rights metadata is the product. An agent that returns a licensed image with its usage terms is categorically more useful than an agent that returns an unlicensed one. That is the shift from portals to surfaces that we track across the AI workflows library: the data stops being a report and becomes an input to a decision.

The tool surface and architecture

The gateway exposes four tools against the Getty Images API:

Each tool is a thin, cached, rate-limited call to the Getty API — the agent surface stays a governed view over the licensed catalog, never a second source of truth, and never a path to unlicensed use.

Step 1: Scaffold the Python FastMCP server

mkdir getty-mcp && cd getty-mcp
python -m venv .venv && source .venv/bin/activate
pip install "fastmcp[cli]" httpx

# server.py
import os
import time
import json
import threading

import httpx
from fastmcp import FastMCP

CLIENT_ID = os.environ["GETTY_CLIENT_ID"]
CLIENT_SECRET = os.environ["GETTY_CLIENT_SECRET"]
TOKEN_URL = os.environ.get("GETTY_TOKEN_URL", "https://oauth.gettyimages.com/oauth2/token")
BASE = os.environ.get("GETTY_BASE", "https://api.gettyimages.com/v3")
DEFAULT_LICENSE = os.environ.get("GETTY_DEFAULT_LICENSE", "royaltyfree")

mcp = FastMCP("getty-mcp", instructions=(
    "Licensed Getty Images search tools. Always return license and usage metadata "
    "with results; prefer royaltyfree or rightsmanaged assets for commercial use."
))

_token = {"value": None, "exp": 0}
_lock = threading.Lock()

def _access_token() -> str:
    with _lock:
        if _token["value"] and _token["exp"] > time.time() + 120:
            return _token["value"]
        r = httpx.post(TOKEN_URL, data={
            "grant_type": "client_credentials",
            "client_id": CLIENT_ID,
            "client_secret": CLIENT_SECRET,
        }, timeout=15)
        r.raise_for_status()
        body = r.json()
        _token.update({"value": body["access_token"],
                       "exp": time.time() + body.get("expires_in", 3600)})
        return _token["value"]

def _headers():
    return {"Authorization": f"Bearer {_access_token()}", "Accept": "application/vnd.getty.images+json"}

@mcp.tool()
def search_creative(query: str, license_model: str = "", limit: int = 10) -> str:
    \"\"\"Search licensed creative imagery; returns assets with rights metadata.\"\"\"
    params = {"phrase": query, "page_size": min(limit, 50),
              "sort_order": "best_match"}
    if license_model:
        params["license_models"] = license_model
    r = httpx.get(f"{BASE}/search/images/creative", params=params,
                  headers=_headers(), timeout=20)
    r.raise_for_status()
    return json.dumps(r.json(), indent=2)

@mcp.tool()
def search_editorial(query: str, editorial_segment: str = "", limit: int = 10) -> str:
    \"\"\"Search editorial imagery (news, events); editorial-use only.\"\"\"
    params = {"phrase": query, "page_size": min(limit, 50),
              "sort_order": "best_match"}
    if editorial_segment:
        params["editorial_segment"] = editorial_segment
    r = httpx.get(f"{BASE}/search/images/editorial", params=params,
                  headers=_headers(), timeout=20)
    r.raise_for_status()
    return json.dumps(r.json(), indent=2)

@mcp.tool()
def get_collections(limit: int = 25) -> str:
    \"\"\"List curated collections for brand-consistent asset selection.\"\"\"
    r = httpx.get(f"{BASE}/collections", params={"page_size": min(limit, 100)},
                  headers=_headers(), timeout=15)
    r.raise_for_status()
    return json.dumps(r.json(), indent=2)

@mcp.tool()
def get_asset_details(asset_id: str) -> str:
    \"\"\"Return full metadata, license model, and resolution for an asset.\"\"\"
    r = httpx.get(f"{BASE}/images/{asset_id}", headers=_headers(), timeout=15)
    r.raise_for_status()
    return json.dumps(r.json(), indent=2)

if __name__ == "__main__":
    mcp.run()

Run the server with python server.py and it speaks MCP over stdio to whichever client you wire next. The critical design detail: search_creative accepts an optional license model but defaults to the GETTY_DEFAULT_LICENSE env var — the gateway is licensed by default, so an agent that forgets to ask for rights still gets rights-clean results.

Step 2: inputSchema definitions published to agents

FastMCP derives JSON Schema from Python type hints, but pinning the contract helps agents call tools correctly:

{
  "search_creative": {
    "type": "object",
    "properties": {
      "query": { "type": "string", "description": "Natural-language image search phrase" },
      "license_model": { "type": "string", "enum": ["royaltyfree", "rightsmanaged"], "description": "Optional; defaults to the configured license" },
      "limit": { "type": "integer", "maximum": 50, "default": 10 }
    },
    "required": ["query"]
  },
  "search_editorial": {
    "type": "object",
    "properties": {
      "query": { "type": "string" },
      "editorial_segment": { "type": "string", "description": "e.g. news, entertainment, sport" },
      "limit": { "type": "integer", "maximum": 50, "default": 10 }
    },
    "required": ["query"]
  },
  "get_asset_details": {
    "type": "object",
    "properties": {
      "asset_id": { "type": "string", "description": "Getty asset ID from a search result" }
    },
    "required": ["asset_id"]
  }
}

Descriptions matter ten times more in agent-facing schemas than in human API docs — the model chooses a tool off the description alone, so say what each tool returns and the rights context in every description string. An agent that understands "editorial-only" before it calls search_editorial is an agent that will not put a news photo in an ad.

Step 3: Wire into Claude Desktop and Cursor

{
  "mcpServers": {
    "getty-mcp": {
      "command": "python",
      "args": ["/absolute/path/to/getty-mcp/server.py"],
      "env": {
        "GETTY_CLIENT_ID": "your-client-id",
        "GETTY_CLIENT_SECRET": "your-client-secret",
        "GETTY_DEFAULT_LICENSE": "royaltyfree"
      }
    }
  }
}

The client secret belongs in your secret manager on the machine running the gateway, never in a committed config. From the Claude Code CLI you can add it with claude mcp add getty -- python /absolute/path/to/getty-mcp/server.py and then confirm with "What MCP tools do you have available?".

OAuth 2.0, license governance, and caching

• Client-credentials flow. The gateway authenticates as a registered Getty application, caching tokens until near expiry. Rotate the client secret centrally and audit every application that has one.
• License governance by default. The gateway defaults to commercially licensed assets and surfaces license metadata in every result. Add a post-filter that rejects editorial-only assets for commercial intents, the same way you would gate any other high-risk agent output.
• Per-application scoping. Issue one client ID per agent or content workflow so a marketing agent and a news agent see different licensing contexts. The GETTY_DEFAULT_LICENSE env var pins the default scope.
• Token-bucket rate limiting. Cap each agent at a modest request rate so a runaway polling loop cannot hammer the API or burn your API quota. Add a per-agent limiter like the ones in our MCP server builds.
• TTL caching. Search results are stable for minutes; a 5-minute cache on search_creative and a 30-minute cache on get_collections cut API calls dramatically for always-on agents while keeping results fresh enough for production use.
• Prompt-injection guard. Treat search phrases and asset IDs as untrusted input; validate asset IDs against the pattern before hitting the API. Pair the gateway with the same screening you apply to your other production agent surfaces.

Step 4: Wire into a LangGraph content-production agent

The gateway is a plain MCP server, so orchestration frameworks connect with the standard adapters:

from langchain_mcp_adapters.tools import load_mcp_tools
from langgraph.prebuilt import ToolNode
from mcp import StdioServerParameters
from mcp.client.stdio import stdio_client
from contextlib import AsyncExitStack

async def tool_node():
    stack = AsyncExitStack()
    params = StdioServerParameters(
        command="python",
        args=["/absolute/path/to/getty-mcp/server.py"],
        env={**os.environ})
    read, write = await stack.enter_async_context(stdio_client(params))
    tools = await load_mcp_tools(read, write)
    return ToolNode(tools)

Inside a LangGraph loop, a content-production agent drafts the article, calls search_creative for a matching licensed hero image, evaluates candidates with get_asset_details, and attaches the best pick with its rights metadata — the same draft-then-enrich pattern you see across the AI workflows library. That is where Getty's launch stops being a data connector and becomes a workflow helper: the agent does the searching and the rights-checking, and the human does the final approval.

Testing the server end to end

python -m fastmcp inspect "$(pwd)/server.py"

> search_creative("autonomous warehouse robots", license_model="royaltyfree", limit=3)
  → 3 assets, all license_model: royaltyfree
  → top hit: asset_id 2004826351, title: "Autonomous robots in warehouse"

> get_asset_details("2004826351")
  → license_model: royaltyfree, max_dimensions: 8000x5000, editorial: false

> search_editorial("EU AI Act hearing", editorial_segment="news", limit=2)
  → 2 assets, editorial_segment: news, license_model: rightsmanaged

The second call is the most important test: get_asset_details returns the rights metadata the content team needs to prove the image is licensed. Then repeat the same prompt in Claude Desktop with the server attached: the second search_creative call should return from cache in single-digit milliseconds — proof the gateway, not the host, is doing the work.

Frequently Asked Questions

What did Getty Images announce on August 12, 2026?

Getty Images launched an MCP Server that connects its creative and editorial content catalog to AI workflows and AI-powered products through a single integration, with the MCP standard handling the connection layer and content metadata.

Why build a custom gateway instead of using the official Getty MCP server?

Use the official server for a quick start. Build a custom FastMCP gateway when you need a narrower approved tool surface, license-aware filtering baked into every search, combined search-then-download workflows in one call, or per-agent rate limits and audit.

How do I keep licensed-content access safe for agents?

Use OAuth 2.0 client-credentials flow with per-application client IDs, filter results to commercially licensed assets by default, apply a token-bucket rate limiter per agent, cache search results with a short TTL, and log every download for license auditing.

What metadata should an agent see before choosing an image?

The license model, usage rights, editorial vs creative classification, resolution, and the asset ID — everything needed to pick an image and prove the rights to use it, without exposing download URLs until selection is final.

What is the realistic agent use case for Getty data?

A content-production agent that drafts an article, searches for licensed imagery that matches the topic, attaches the best candidates with rights metadata, and sends the package to a human for final approval — image selection inside the writing workflow.

Closing thoughts

Getty's August 12 launch is the licensed-content industry's MCP moment: the catalog is no longer trapped behind a human-facing search UI, it is a tool an agent can call with rights metadata attached. Production use still demands the boring engineering around the API — vaulted credentials, license-aware defaults, per-agent rate limits, and caches — but the payoff is an agent that produces commercially usable content, imagery included, inside the same workflow that drafts the copy. Track more builds like this one in the MCP directory and keep an eye on AI news as more licensed-content platforms follow Getty's lead.