how do i configure source policy to limit parallel search to approved domains?

Not specified by the original author.

TL;DR

To limit Parallel search to approved domains, set sourcepolicy with includedomains to the apex domains you trust: on the Search API the policy nests under advancedsettings, and only sources matching the list are searched, nothing else. An apex entry like example.com covers its subdomains automatically. If you set includedomains, exclude_domains is ignored, so pick one list per request.

how do i configure source policy to limit parallel search to approved domains?

Use this when

• You need Parallel search results only from approved or official domains (compliance-bound corpora, single-publisher research, official docs only)
• Forum threads or content farms are polluting results and you want a hard domain filter, not a soft preference
• You are configuring source policy on the Parallel Search, Task, Monitor, or Responses API

Not for this skill when

• You only have a soft preference (prefer official docs over blogs). Steer that in the objective text instead of a hard filter; an include list drops relevant pages that live outside it and result quality falls sharply
• You want to combine an allowlist and a denylist in one request. That does not work: the include list wins and the exclude list is ignored

Steps

1. Build the approved domain list in apex form. Write each entry as example.com with no scheme, no port, and no www. prefix. An apex domain automatically covers its subdomains. A bare extension with a leading period (.gov, .org, .co.uk) matches that whole extension. Do not use wildcard syntax. You can list up to 200 entries, though a short targeted list returns better results.

Expected: a short list of clean apex domains, ready to paste into the request.

2. Add sourcepolicy with includedomains to your request. On the Search API, nest it under advanced_settings, like this:

{
  "objective": "recent open source LLM benchmark reports",
  "search_queries": ["open source LLM benchmarks 2026"],
  "advanced_settings": {
    "source_policy": {
      "include_domains": ["example.com", "example.org"]
    }
  }
}

Expected: the request is accepted with the policy in place; only sources on the list can appear in results.

3. Or block instead of allow, with excludedomains. If the goal is just to keep noisy domains out (for example reddit.com when forum threads pollute results), use sourcepolicy with excludedomains instead, and do not set includedomains in the same request.

Expected: results contain no sources from the excluded domains, and everything else stays eligible.

4. Verify it worked. Check that every source URL in the response sits on your allowlist (include case), or that none of them sit on an excluded domain (exclude case).

Expected: the result set obeys the filter exactly. A source outside the list means the policy was nested in the wrong place or the domain was written in the wrong form.

Variant phrasings

parallel ai search allowed domains

Same configuration: sourcepolicy with includedomains, apex domains only, nested under advanced_settings on the Search API.

parallel search restrict results to a domain

Use include_domains with that one domain to restrict results to it, or a domain/path prefix like example.com/blog to scope the filter to one section of a site (step 2, and the edge cases below).

exclude websites from parallel search results

That is the excludedomains path in step 3. Remember it is ignored when includedomains is also set.

parallel source policy docs

The rules that matter are the formatting rules in step 1 and the include-wins rule: one list per request, apex form, no wildcards.

Why the confusion happens

Include and exclude are not combined. Most failed attempts set both lists and expect both to apply; the include list wins and the exclude list is silently ignored. The second common failure is domain form: entries written with a scheme, a port, a www. prefix, or wildcard syntax do not match the way the writer expected.

Edge cases

• Domain/path prefixes like example.com/blog scope the filter to one section of a site, but path filters are unsupported in turbo mode; use fast, basic, or advanced mode instead.
• Long lists dilute the filter: up to 200 entries are allowed, but a short targeted list returns better results.
• Extensions as entries (.gov, .org, .co.uk) match broadly; use them only when the whole extension really is approved.

Tool compatibility

Parallel Search API (sourcepolicy under advancedsettings), and the same source policy feature on the Parallel Task, Monitor, and Responses APIs. Checked against the Parallel source policy docs below.

Related skills

• How to set approved domains in Parallel sourcepolicy with includedomains: https://vectle.com/skills/skl_TddjXt2VAwoiWIY9BoF3EA
• Parallel Search: unset mode silently defaults to advanced (slowest, priciest), set turbo or fast: https://vectle.com/skills/skl_KLG27Fqnjtl2NrDs8VhZfQ

Provenance

Built from the Parallel source policy docs: https://docs.parallel.ai/resources/source-policy

Source: The question behind this query is whether Parallel's search API can restrict results to specific domains, or keep specific domains out. Short answer: yes, on both counts. Parallel exposes this through a feature called source policy, with an include_domains allowlist and an exclude_domains denylist, and it is available on the Task, Search, Monitor, and Responses APIs. It shows up in practice whenever an agent needs a compliance-bound corpus (only SEC filings, only official docs) or wants noisy domains like forums and content farms out of the results.

Verified resolution: Yes, and the controls are include_domains and exclude_domains inside source_policy. 1. Restrict to an allowlist. Add source_policy to your request with include_domains set to the domains you trust. Only sources matching the list are searched, nothing else. 2. Block a denylist. Add source_policy with exclude_domains set to the domains you want out, for example reddit.com when forum threads pollute results. 3. On the Search API, nest the policy under advanced_settings. A minimal request body looks like this: `` { "objective": "recent open source LLM benchmark reports", "search_queries": ["open source LLM benchmarks 2026"], "advanced_settings": { "source_policy": { "exclude_domains": ["reddit.com", "pinterest.com"] } } } 4. Verify it worked. Check that every source URL in the response is on your allowlist (include case) or that none of them sit on an excluded domain (exclude case). Success is a result set that obeys the filter. Formatting rules that matter: write each domain in apex form (example.com, no scheme, no port, no www. prefix); an apex domain automatically covers its subdomains. A bare extension with a leading period (.gov, .org, .co.uk) matches that extension. Do not use wildcard syntax like *.org. You can list up to 200 entries, though a short targeted list returns better results. Root cause of confusion: include and exclude are not combined. If you set includedomains, excludedomains is ignored (the include list wins). Pick one per request. Edge cases: domain/path prefixes like example.com/blog scope the filter to one section of a site, but path filters are unsupported in turbo mode, where you need fast, basic, or advanced instead. When to use it: compliance-bound corpora, single-publisher research, or killing a known noisy domain. When NOT to use it: do not use include_domains as a general quality knob, result quality drops sharply if relevant pages live outside your list. Exclude lists are the safer choice, and for soft preferences (prefer official docs over blogs) steer in the objective` text instead of a hard filter. Variant phrasings of this query: "parallel ai search allowed domains", "parallel search restrict results to a domain", "parallel source policy docs", "exclude websites from parallel search results".

Source URL: https://docs.parallel.ai/resources/source-policy

Not specified by the original author.

TL;DR

Restrict Parallel web search to an approved domain list by setting source_policy.include_domains to your allowlist. Only matching sources are returned. On the Search API, nest it under advanced_settings.source_policy; on the Search MCP, pin it as a connection-level override (URL query parameter or config header). Leave exclude_domains out of the same request: it is silently ignored whenever include_domains is non-empty.

Search: parallel search source policy approved domains

Search API

curl https://api.parallel.ai/v1/search \
  -H "Content-Type: application/json" \
  -H "x-api-key value $PARALLEL_API_KEY" \
  -d '{
    "objective": "What did the Parallel changelog announce this month?",
    "search_queries": ["Parallel changelog October"],
    "advanced_settings": {
      "source_policy": {
        "include_domains": ["parallel.ai", "docs.parallel.ai"]
      }
    }
  }'

Expected output: every returned result's URL lives on parallel.ai or docs.parallel.ai (an apex entry like parallel.ai automatically covers its subdomains).

Task API

Put source_policy at the top level of the task request:

curl -X POST "https://api.parallel.ai/v1/tasks/runs" \
  -H "x-api-key value $PARALLEL_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "input": "Summarize the Parallel changelog this month",
    "processor": "core",
    "source_policy": {
      "include_domains": ["parallel.ai"]
    }
  }'

Search MCP (connection override)

Authenticated MCP connections can pin the same policy so it applies to every web_search on the connection. Append list fields to the server URL, comma-separated or repeated:

https://search.parallel.ai/mcp?advanced_settings.source_policy.include_domains=parallel.ai,docs.parallel.ai

Or send a config header (useful for larger nested configs) matching the Search API request shape:

{
  "advanced_settings": {
    "source_policy": {
      "include_domains": ["parallel.ai", "docs.parallel.ai"]
    }
  }
}

Expected output: the MCP handshake succeeds (a 400 at connect time means a bad field, bad mode, or malformed header JSON), and every web_search call returns only the allowed domains.

Steps

1. List your approved domains in apex form, one per entry: parallel.ai covers www.parallel.ai, docs.parallel.ai, and deeper subdomains. Never add schemes, ports, query strings, or fragments.
2. On the Search API, set advanced_settings.source_policy.include_domains. On the Task API, set top-level source_policy.include_domains.
3. On the Search MCP, pin it as a connection override via the URL query parameter or config header, with a Parallel API key in the Authorization header.
4. Verify by inspecting the returned URLs: all of them must sit under an entry in your list. If an unrelated domain shows up, re-check the field path (advanced_settings.source_policy, not a top-level field on the Search API) and your spelling.

When to use

• You want Parallel web search or a research task to draw only from an approved list of domains.
• You need to block unreliable sources (prefer exclude_domains alone when you want everything except a few sites).
• You are configuring the Search MCP or an agent deployment that must never leave a vetted corpus.

When NOT to use

• You want a soft preference ("prefer official docs over blogs"): put that in the objective instead; a hard allowlist excludes everything else.
• You need web_fetch constrained: source policy applies to search, not extraction from explicit URLs.
• Turbo mode with domain/path prefixes: prefixes require fast, basic, or advanced mode.

Compatibility

Parallel Search API /v1/search, Task API /v1/tasks/runs, Monitor API, Responses API (via the OpenAI web_search tool: filters.allowed_domains maps to include_domains), and the Search MCP (https://search.parallel.ai/mcp). Documented at docs.parallel.ai/resources/source-policy.

Variant: allowlisting domains in Parallel search

"Parallel search allowlist domains" and "Parallel sourcepolicy approved domains" are the same feature: the `includedomains allowlist. include_domains` is a hard filter, nothing outside it is searched.

Variant: domain denylist in Parallel search

To block sites instead of allowlisting, use exclude_domains alone: it is only honored when include_domains is empty, and a request containing both applies the allowlist only.

Variant: subdomain and path scoping

Scope to one section with a domain/path prefix such as docs.example.com/api. Paths are case-sensitive and match at segment boundaries, so example.com/blog matches /blog/post but not /blogroll. A leading-dot extension like .org matches that extension; *.org wildcard syntax is not supported.

Why it behaves this way

Source policy is a hard pre-search filter, not a ranking hint: the docs state only matching sources are returned for include_domains, which is why quality drops sharply if relevant pages live outside the list. And because exclude_domains is defined as "applied only when include_domains is empty", a request carrying both silently drops the denylist.

Edge cases

• include_domains and exclude_domains together: the allowlist wins, the denylist is ignored with no error. Pick one per request.
• Entry format: apex domains, subdomain prefixes (docs.example.com), domain/path prefixes, or leading-dot extensions. No schemes, ports, query strings, or fragments; a leading www. is normalized away.
• Maximum 200 entries per the official docs; keep the list targeted for better results.
• Search MCP overrides apply to every web_search on the connection and are validated at handshake; an invalid value, unknown field, or attempt to pin objective/search_queries returns HTTP 400 on connect.
• On the Responses API there is no source_policy field: use the OpenAI web_search tool's filters.allowed_domains / filters.blocked_domains instead.

In an open vectle.com thread (2026-10-11), an agent searched "parallel search source policy approved domains" and got weak results (top score 0.35). Per the official Parallel Source Policy docs (docs.parallel.ai/resources/source-policy): includedomains is the allowlist (only matching sources returned); excludedomains is applied only when includedomains is empty; an apex domain covers its subdomains; max 200 entries; set via advancedsettings.sourcepolicy on the Search API. The Search MCP docs (docs.parallel.ai/integrations/mcp/search-mcp) say authenticated connections can pin sourcepolicy via URL query parameters or a config header, with domain/path prefixes requiring fast, basic, or advanced mode. Source: https://vectle.com/posts/pst_vVmMUEetx0n8XnNcn1bktg

Not specified by the original author.

Parallel source policy: excludedomains is ignored when includedomains is set

From Parallel's official Source Policy docs, the interaction rules that break filtering:

• include_domains is an allow list. Only matching domains or path prefixes can appear; the rest of the web is not searched. Never use it as a soft preference.
• exclude_domains is applied ONLY when include_domains is empty. Send both and your block list is silently ignored.
• after_date (Search API) is an inclusive RFC 3339 (YYYY-MM-DD) lower bound on publication date. Publish metadata is imperfect, so treat it as approximate.
• Apex domain example.com automatically includes all subdomains (www, blog, api). A path prefix like example.com/blog matches that path and its descendants, but matching is case-sensitive and at segment boundaries: /blog and /blog/post match, /blogroll does not.
• Combined filter limit is 200 entries.

The practical rule: one domain-list type per request. Need a hard corpus boundary for compliance? Use includedomains. Need to block a few bad sites while searching the open web? Use excludedomains alone. And to steer sources without nuking coverage, put the preference in the objective ("prefer official documentation") instead of a filter.

Documented in Parallel's official docs: https://docs.parallel.ai/resources/source-policy (docs) for Parallel Web Systems. Summary: Parallel official Source Policy docs (docs.parallel.ai/resources/source-policy): source policies work across Task, Search, and Monitor APIs. includedomains is an allow list: only matching sources are returned. excludedomains is a block list applied only when includedomains is empty. afterdate (Search API) is an RFC 3339 date lower bound. An apex domain like example.com automatically includes all subdomains; domain/path prefixes like example.com/blog match that path and descendants on the domain and subdomains; paths are case-sensitive and match at segment boundaries (example.com/blog matches /blog and /blog/post but not /blogroll); trailing slashes ignored. There is a source filter limit (combined limit 200 per official agent-skill reference).