Enable Safe Search to Filter Adult Content

Protecting your users from explicit content is a first-class concern for any search application, especially those that serve children, students, or workplace audiences. The Custom Search JSON API provides a safe parameter that maps directly to Google’s SafeSearch technology — the same system that powers Safe Search in Google Search. This guide explains the two available values, their default behavior, when to use each, and what compliance considerations apply when your application is accessible to minors.

The `safe` parameter

Add safe to any Custom Search API request to control how Google’s SafeSearch filter is applied to results.

Value	Behavior
`active`	Enable SafeSearch filtering. Explicit results are removed from the response.
`off`	Disable SafeSearch filtering. All results matching the query are returned.

The default behavior when safe is omitted is equivalent to safe=off — no filtering is applied. Always set safe=active explicitly if your application serves audiences that should not see adult content.

When to use `safe=active`

Use safe=active whenever any of the following conditions apply:

Your application is accessible to minors. Schools, children’s content platforms, and family-oriented services must filter explicit content to comply with laws such as COPPA (US), GDPR-K (EU), and KOSA (US).
Your application is used in a workplace or institutional context. Many organizations have acceptable-use policies that prohibit explicit content on corporate networks and devices.
Your application is a general-purpose search tool with a public, unverified audience. When you cannot confirm users are adults, defaulting to active is the safer choice.
You are embedding search into an app store listing or marketplace that prohibits adult content in user-accessible features.

GET https://www.googleapis.com/customsearch/v1
  ?key=YOUR_API_KEY
  &cx=YOUR_SEARCH_ENGINE_ID
  &q=animals+for+kids
  &safe=active

When to use `safe=off`

Use safe=off only when you have verified that your application:

Serves an adult audience that has actively opted in to or acknowledged the possibility of explicit content.
Is an age-verified platform with appropriate legal safeguards (e.g., 18+ verification, content warnings, and terms of service that address adult content).
Requires unfiltered results for legitimate research, journalism, or academic purposes where excluding explicit content would compromise result accuracy.

Leaving safe unset (which defaults to off) in an application accessible to children may violate applicable laws and your platform’s terms of service. Be explicit — set safe=active as the default in any application where user age is unknown or unverified.

Adding `safe` to your requests

const API_KEY = 'YOUR_API_KEY';
const CX = 'YOUR_SEARCH_ENGINE_ID';
const BASE_URL = 'https://www.googleapis.com/customsearch/v1';

async function search(query, { safe = 'active', num = 10, start = 1 } = {}) {
  const params = new URLSearchParams({
    key: API_KEY,
    cx: CX,
    q: query,
    safe,
    num,
    start,
  });

  const response = await fetch(`${BASE_URL}?${params}`);

  if (!response.ok) {
    const err = await response.json().catch(() => ({}));
    throw new Error(err?.error?.message ?? `HTTP ${response.status}`);
  }

  return response.json();
}

// Safe Search enabled (recommended default)
const safeResults = await search('animals for kids', { safe: 'active' });

// Safe Search disabled (adult / age-verified platform only)
const unfiltered = await search('photography techniques', { safe: 'off' });

import requests

API_KEY = "YOUR_API_KEY"
CX = "YOUR_SEARCH_ENGINE_ID"
BASE_URL = "https://www.googleapis.com/customsearch/v1"


def search(
    query: str,
    safe: str = "active",
    num: int = 10,
    start: int = 1,
) -> dict:
    """
    Search using the Custom Search JSON API.

    Args:
        query: The search query string.
        safe:  SafeSearch setting — 'active' (filter) or 'off' (no filter).
        num:   Number of results to return (1–10).
        start: 1-based index of the first result.

    Returns:
        Parsed JSON response dict.
    """
    if safe not in ("active", "off"):
        raise ValueError("safe must be 'active' or 'off'.")

    params = {
        "key": API_KEY,
        "cx": CX,
        "q": query,
        "safe": safe,
        "num": num,
        "start": start,
    }

    response = requests.get(BASE_URL, params=params, timeout=10)
    response.raise_for_status()
    return response.json()


# Safe Search enabled (recommended default)
safe_results = search("animals for kids", safe="active")

# Safe Search disabled (adult / age-verified platform only)
unfiltered = search("photography techniques", safe="off")

# With Safe Search enabled
curl -G "https://www.googleapis.com/customsearch/v1" \
  --data-urlencode "key=YOUR_API_KEY" \
  --data-urlencode "cx=YOUR_SEARCH_ENGINE_ID" \
  --data-urlencode "q=animals for kids" \
  --data-urlencode "safe=active"

# With Safe Search disabled
curl -G "https://www.googleapis.com/customsearch/v1" \
  --data-urlencode "key=YOUR_API_KEY" \
  --data-urlencode "cx=YOUR_SEARCH_ENGINE_ID" \
  --data-urlencode "q=photography techniques" \
  --data-urlencode "safe=off"

Applying Safe Search to image searches

Safe Search is especially important for image results, where explicit content is more immediately visible. Set both searchType=image and safe=active together:

GET https://www.googleapis.com/customsearch/v1
  ?key=YOUR_API_KEY
  &cx=YOUR_SEARCH_ENGINE_ID
  &q=sunset+photos
  &searchType=image
  &safe=active

Even with safe=active, you should implement client-side image loading safeguards — such as lazy loading with explicit dimensions and a placeholder — to prevent layout shifts and inadvertent rendering of images that slip past any filter.

Compliance considerations for apps serving minors

If your application is directed at children under 13 (US) or under 16 (EU), or if it is a general-purpose tool that children can access, be aware of the following:

COPPA (Children's Online Privacy Protection Act — US)

COPPA applies to websites and online services directed at children under 13 that collect personal information. While COPPA primarily governs data collection, the FTC expects operators to take reasonable steps to provide a safe environment. Enabling safe=active is a baseline measure consistent with this expectation. Consult legal counsel for full COPPA compliance requirements.

App store policies (Apple App Store, Google Play)

Both Apple and Google require that apps rated for general audiences or children include appropriate content filtering. If your app is rated 4+ (Apple) or Everyone (Google Play), you must prevent access to adult content. Enabling safe=active is a necessary (but not sufficient) step — also review your app’s content rating and parental controls documentation.

School and institutional deployments

The Children’s Internet Protection Act (CIPA) requires US schools and libraries that receive E-rate funding to implement internet filtering. If you are deploying a search tool in a school context, safe=active should be mandatory and ideally non-overridable by students. Consider removing any UI controls that would let users toggle Safe Search off.

Locking Safe Search in your UI

If your application serves an audience where safe search must always be on, don’t expose a toggle. Set safe=active server-side and omit any front-end controls that would allow users to change the setting:

# GOOD: safe is hardcoded; users cannot change it
def search_for_students(query: str) -> dict:
    return search(query, safe="active")


# BAD: user input is trusted directly — never do this
def search_unsafe(query: str, user_safe_preference: str) -> dict:
    return search(query, safe=user_safe_preference)

Even if a user modifies their browser request to omit the safe parameter or set it to off, your backend proxy layer should always re-apply safe=active before forwarding the request to the Google API. Never pass through user-controlled values for the safe parameter in child-safe applications.

Summary

Scenario	Recommended setting
Children’s app, school tool, family platform	`safe=active` (hardcoded, non-overridable)
General-purpose app, unknown audience	`safe=active` (default)
Adult platform, age-verified users	`safe=off` (with appropriate legal safeguards)
Image search on any public platform	`safe=active`
No `safe` parameter set	Equivalent to `safe=off` — not recommended

Next steps

Build a Search App

See Safe Search wired into a complete end-to-end search application.

Localization

Combine Safe Search with language and region settings for a fully controlled experience.

Get Started

Core Concepts

Search Features

Guides

Help

Enable Safe Search to Filter Adult Content

The `safe` parameter

When to use `safe=active`

When to use `safe=off`

Adding `safe` to your requests

Applying Safe Search to image searches

Compliance considerations for apps serving minors

Locking Safe Search in your UI

Summary

Next steps

Build a Search App

Localization

​The safe parameter

​When to use safe=active

​When to use safe=off

​Adding safe to your requests

​Applying Safe Search to image searches

​Compliance considerations for apps serving minors

​Locking Safe Search in your UI

​Summary

​Next steps

Build a Search App

Localization

The `safe` parameter

When to use `safe=active`

When to use `safe=off`

Adding `safe` to your requests

Applying Safe Search to image searches

Compliance considerations for apps serving minors

Locking Safe Search in your UI

Summary

Next steps