Discover/Perforce API
live

Perforce APIhelp.perforce.com

Access P4 command reference data via API: command syntax, form fields, client options, configurables, and documentation search across Perforce Helix Core.

Endpoint health
verified 3d ago
get_client_page
get_command_page
get_configurables_reference
get_client_options_field
get_client_form_fields
9/9 passing latest checkself-healing
Endpoints
9
Updated
26d ago

What is the Perforce API?

This API exposes 9 endpoints that surface structured data from the Perforce Helix Core (P4) command reference documentation at help.perforce.com. Use get_command_page to retrieve syntax, options, usage notes, and examples for any named p4 command, or call get_command_reference_index to get the full alphabetical list of commands with their documentation URLs. Other endpoints cover client spec fields, submit options, line-end modes, and the full configurables table.

Try it

No input parameters required.

api.parse.bot/scraper/67011ff8-8139-4603-b730-d9cc70602c50/<endpoint>
Ready to send
Fill in the parameters and hit sign in to send to see live response data here.
Call it over HTTPgrab a free API key at signup
curl -X GET 'https://api.parse.bot/scraper/67011ff8-8139-4603-b730-d9cc70602c50/get_client_options_field' \
  -H 'X-API-Key: $PARSE_API_KEY'
Python SDK · recommended

Typed, relational, agent-ready

A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.

  • Fully typed · autocompletes
  • Objects link to objects
  • Typed errors & pagination

Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:

uv add parse-sdk
uv run parse init
uv run parse add --marketplace help-perforce-com-api

uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.

"""Walkthrough: P4Docs SDK — browse commands, search docs, inspect configurables."""
from parse_apis.perforce_p4_cli_documentation_api import P4Docs, Query, CommandName, CommandNotFound

client = P4Docs()

# List available commands from the reference index.
for cmd_summary in client.commandsummaries.list(limit=5):
    print(cmd_summary.command, cmd_summary.url)

# Drill into a specific command's full documentation.
sync_cmd = client.commands.get(command_name=CommandName.P4_SYNC)
print(sync_cmd.syntax)
for opt in sync_cmd.options[:3]:
    print(opt.flag, opt.description[:60])

# Search documentation for a topic.
result = client.searchresults.search(query=Query.SYNC, limit=1).first()
if result:
    print(result.title, result.abstract[:80])

# Navigate from a summary to full command details.
first_summary = client.commandsummaries.list(limit=1).first()
if first_summary:
    detail = first_summary.details()
    print(detail.command, detail.syntax)

# Typed error handling for a missing command.
try:
    client.commands.get(command_name="p4 nonexistent")
except CommandNotFound as exc:
    print(f"Not found: {exc.command_name}")

# Fetch the full p4 client reference page.
client_page = client.clientpages.get()
print(client_page.title, client_page.syntax[:60])

# Inspect client workspace options and configurables.
for opt in client.clientoptions.list(limit=3):
    print(opt.option, opt.default, opt.meaning[:50])

for cfg in client.configurables.list(limit=3):
    print(cfg.name, cfg.client_server_proxy, cfg.default)

print("Exercised: commandsummaries.list / commands.get / searchresults.search / details / clientpages.get / clientoptions.list / configurables.list")
All endpoints · 9 totalmissing one? ·

Returns all valid values for the Options field of a p4 client spec, including both affirmative and negated ([no]-prefixed) variants, along with their descriptions and defaults.

Input

No input parameters required.

Response
{
  "type": "object",
  "fields": {
    "items": "array of client option objects with option, raw_text, meaning, and default"
  },
  "sample": {
    "data": {
      "items": [
        {
          "option": "allwrite",
          "default": "noallwrite",
          "meaning": "If allwrite is set, unopened files are left writable.",
          "raw_text": "[no]allwrite"
        }
      ]
    },
    "status": "success"
  }
}

About the Perforce API

Command Reference

get_command_reference_index returns every p4 command listed in the alphabetical index, each with a command name and url. From there, get_command_page accepts a command_name parameter — with or without the p4 prefix — and returns structured fields including syntax, description, options (an array of flag/description pairs), usage_notes, and examples. Any of these fields may be null if the documentation page for that command omits the section.

Client Spec Data

Three endpoints dissect the p4 client specification. get_client_form_fields returns every field in the client spec with a field name, inferred type_hint, and description. get_client_options_field enumerates the Options field values, including both affirmative and [no]-prefixed negated variants, with their meaning and default values. get_client_submit_options lists each SubmitOptions value and what it controls about unchanged-file handling during submit. get_client_line_end_options covers each LineEnd value and its workspace line-ending behavior.

Configurables and Search

get_configurables_reference returns the full configurables table — each entry includes the configurable name, client_server_proxy scope tag, default value, and description. This covers server, client, and proxy tunables in a single response.

search_documentation accepts a query string and performs a token-based match against documentation topic titles and abstracts. All space-separated tokens must appear in a topic for it to match. The endpoint scans the first three index chunks, so very broad queries or topics covered only in later chunks may return incomplete results.

Reliability & maintenanceVerified

The Perforce API is a managed, monitored endpoint for help.perforce.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when help.perforce.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.

This isn't an official help.perforce.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.

Last verified
3d ago
Latest check
9/9 endpoints passing
Maintenance
Monitored & self-healing
Will this API break when the source site changes?+
It's built not to. Every endpoint is health-checked on a schedule with automated test probes. When the source site changes and a check fails, the API is automatically queued for repair and re-verified — that's the self-healing layer. Each API page shows when its endpoints were last verified. And because marketplace APIs are shared, any fix reaches everyone using it.
Is this an official API from the source site?+
No — Parse APIs are independent, managed REST wrappers over publicly available data. That is the point: where a site has no official API (or only a limited one), Parse gives you a maintained, monitored endpoint for that data and keeps it working as the site changes — so you get a stable contract over a source that never promised one.
Can I fix or extend this API myself if I need a new endpoint or field?+
Yes — and you don't have to wait on us. This API was generated by the Parse agent, which stays attached. Describe the change in plain English ("add an endpoint that returns reviews", "fix the price field") in the revise box on the API page or via the revise_api MCP tool, and the agent rebuilds it against the live site in minutes. Contributing the change back to the public API is free.
What happens if I call an endpoint that has an issue?+
Errors are machine-readable: a bad call returns a clean status with the list of available endpoints and a repair hint, so an agent (or you) can recover or trigger a fix instead of failing silently. Confirmed failures feed the automatic repair queue.
Common use cases
  • Build a CLI tool that auto-completes p4 command flags by pulling options arrays from get_command_page.
  • Generate internal developer wikis by iterating get_command_reference_index and fetching descriptions per command.
  • Validate client spec forms against the canonical field list returned by get_client_form_fields.
  • Audit workspace configurations by comparing in-use Options values against the defaults in get_client_options_field.
  • Surface configurable tuning recommendations by querying get_configurables_reference for defaults and scope.
  • Add P4 documentation lookup to a chatbot or IDE plugin using search_documentation plus get_command_page.
  • Detect deprecated or non-standard SubmitOptions in client specs by cross-referencing get_client_submit_options values.
Pricing & limitsSee full pricing →
TierPriceCredits/monthRate limit
Free$0/mo1005 req/min
Hobby$30/mo1,00020 req/min
Developer$100/mo5,000100 req/min

One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.

Frequently asked questions
Does Perforce provide an official developer API for its documentation?+
Perforce does not publish a public REST or developer API for help.perforce.com documentation content. The Perforce developer hub at https://www.perforce.com/manuals covers the P4 API (C library) and P4Python/P4Java SDKs for interacting with a Helix Core server, but those are separate from documentation retrieval.
What does `get_command_page` return, and which fields can be null?+
get_command_page returns syntax, description, options, usage_notes, and examples for the requested command. The syntax, description, usage_notes, and examples fields are typed as string-or-null — if the documentation page for a given command omits that section, the field returns null. The options array will be empty rather than null when no flags are documented.
Does `search_documentation` cover the full P4 documentation set?+
Not fully. The endpoint searches only the first three index chunks of the client-side search index, so topics indexed in later chunks may not appear in results. It also requires all query tokens to match a topic's title or abstract, so partial-word or synonym queries will miss results. You can fork this API on Parse and revise it to load additional index chunks or implement fuzzy matching.
Does the API cover P4 admin commands or server-side commands beyond the standard command reference?+
The API covers commands listed in the alphabetical p4 command reference index at help.perforce.com, along with client spec fields and the configurables reference. P4 admin (p4d) server administration commands and separate product documentation (e.g., Helix Swarm, GitFusion) are not currently covered. You can fork this API on Parse and revise it to add endpoints targeting those documentation sections.
What does `get_client_options_field` return that `get_client_form_fields` does not?+
get_client_form_fields gives one entry per spec field with a type hint and description. get_client_options_field specifically enumerates every valid token for the Options field itself — including the negated [no]-prefixed variants — with individual meaning and default values per token. It is more granular for programmatic validation of the Options string.
Page content last updated . Spec covers 9 endpoints from help.perforce.com.
Related APIs in Developer ToolsSee all →
git-scm.com API
Access comprehensive Git documentation, browse command references across different versions, and explore chapters from the Pro Git book. Search Git documentation and glossary terms to quickly find answers about Git commands and concepts.
Docs.copia.io API
Search and browse the complete Copia Automation documentation, discover available pages, and retrieve full text content from any page on docs.copia.io. Quickly find answers by searching documentation content or accessing specific guides and references.
developers.notion.com API
Search and browse Notion's developer documentation to find specific pages and retrieve their full content in markdown format. Access comprehensive information about Notion's capabilities by listing available pages or looking up individual documentation entries.
soliditylang.org API
Access comprehensive Solidity documentation, search language references, and browse blog posts to stay updated on development news. Query compiler bug data filtered by version to identify known issues and compatibility concerns across smart contract projects.
docs.centrifuge.io API
Access comprehensive Centrifuge protocol information including documentation, pools, tokens, vaults, and investor data through intelligent search and navigation tools. Query transaction history, investment positions, and detailed protocol metrics across the Centrifuge ecosystem.
quickref.me API
Search and retrieve quick reference guides for hundreds of developer tools, languages, and frameworks from quickref.me. Browse all available cheatsheets, search by keyword, or fetch full content for any topic to instantly access the commands, syntax, and usage notes you need.
docs.opensearch.org API
Search OpenSearch documentation across multiple versions, retrieve specific page content, discover breaking changes, and navigate the docs structure all from a single interface. Instantly find answers by searching the docs or get a complete overview of available versions and site navigation.
deepwiki.com API
Search and retrieve documentation for any GitHub repository indexed on DeepWiki, including wiki pages, table of contents, and source file references in markdown format. Look up repository profiles, discover featured projects, and access complete wiki content all in one place.