> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://platform.bctrl.ai/llms.txt.
> For full documentation content, see https://platform.bctrl.ai/llms-full.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://platform.bctrl.ai/_mcp/server.

# Get API, SDK, and CLI Help

GET https://api.bctrl.ai/v1/help

Return global API, SDK, and CLI help, or help for one named topic. Use query parameters so help is easy to call from browsers, CLI tools, SDKs, and plain HTTP clients.

Reference: https://platform.bctrl.ai/api/api-reference/help/get

## OpenAPI Specification

```yaml
openapi: 3.1.0
info:
  title: bctrl API
  version: 1.0.0
paths:
  /v1/help:
    get:
      operationId: help
      summary: Get API, SDK, and CLI help
      description: >-
        Return global API, SDK, and CLI help, or help for one named topic. Use
        query parameters so help is easy to call from browsers, CLI tools, SDKs,
        and plain HTTP clients.
      tags:
        - ''
      parameters:
        - name: topic
          in: query
          required: false
          schema:
            type: string
        - name: audience
          in: query
          required: false
          schema:
            $ref: '#/components/schemas/V1HelpGetParametersAudience'
        - name: Authorization
          in: header
          description: Use Bearer <api-key>.
          required: true
          schema:
            type: string
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/HelpResponse'
        '401':
          description: 'Authentication required: the API key is missing or invalid.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
        '403':
          description: 'Forbidden: the API key cannot access this resource.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/ErrorResponse'
servers:
  - url: https://api.bctrl.ai
    description: Production
  - url: http://localhost:8787
    description: Local development gateway
components:
  schemas:
    V1HelpGetParametersAudience:
      type: string
      enum:
        - api
        - sdk
        - cli
      title: V1HelpGetParametersAudience
    HelpResponseDiscriminatorMappingOverviewAudience:
      type: string
      enum:
        - api
        - sdk
        - cli
      title: HelpResponseDiscriminatorMappingOverviewAudience
    HelpExampleAudience:
      type: string
      enum:
        - api
        - sdk
        - cli
      title: HelpExampleAudience
    HelpExampleRequest:
      type: object
      properties: {}
      title: HelpExampleRequest
    HelpExample:
      type: object
      properties:
        audience:
          $ref: '#/components/schemas/HelpExampleAudience'
        code:
          type: string
        command:
          type: string
        language:
          type: string
        request:
          $ref: '#/components/schemas/HelpExampleRequest'
        title:
          type: string
      title: HelpExample
    HelpNextStepAudience:
      type: string
      enum:
        - api
        - sdk
        - cli
      title: HelpNextStepAudience
    HelpNextStepMethod:
      type: string
      enum:
        - GET
        - POST
        - PATCH
        - PUT
        - DELETE
      title: HelpNextStepMethod
    HelpNextStep:
      type: object
      properties:
        audience:
          $ref: '#/components/schemas/HelpNextStepAudience'
        command:
          type: string
        method:
          $ref: '#/components/schemas/HelpNextStepMethod'
        path:
          type: string
        title:
          type: string
        topic:
          type: string
      title: HelpNextStep
    HelpTopicAudiencesItems:
      type: string
      enum:
        - api
        - sdk
        - cli
      title: HelpTopicAudiencesItems
    HelpTopicMethod:
      type: string
      enum:
        - GET
        - POST
        - PATCH
        - PUT
        - DELETE
      title: HelpTopicMethod
    HelpTopic:
      type: object
      properties:
        aliases:
          type: array
          items:
            type: string
        audiences:
          type: array
          items:
            $ref: '#/components/schemas/HelpTopicAudiencesItems'
        method:
          $ref: '#/components/schemas/HelpTopicMethod'
        operationId:
          type: string
        path:
          type: string
        summary:
          type: string
        title:
          type: string
        topic:
          type: string
      required:
        - audiences
        - summary
        - title
        - topic
      title: HelpTopic
    HelpApiOperationMethod:
      type: string
      enum:
        - GET
        - POST
        - PATCH
        - PUT
        - DELETE
      title: HelpApiOperationMethod
    HelpApiOperation:
      type: object
      properties:
        method:
          $ref: '#/components/schemas/HelpApiOperationMethod'
        operationId:
          type: string
        path:
          type: string
        requestFields:
          type: array
          items:
            type: string
        responseFields:
          type: array
          items:
            type: string
      required:
        - method
        - path
      title: HelpApiOperation
    HelpTopicResponseAudience:
      type: string
      enum:
        - api
        - sdk
        - cli
      title: HelpTopicResponseAudience
    HelpFlag:
      type: object
      properties:
        description:
          type: string
        name:
          type: string
        value:
          type: string
      required:
        - description
        - name
      title: HelpFlag
    HelpCliCommand:
      type: object
      properties:
        command:
          type: string
        flags:
          type: array
          items:
            $ref: '#/components/schemas/HelpFlag'
        usage:
          type: string
      required:
        - command
        - usage
      title: HelpCliCommand
    HelpField:
      type: object
      properties:
        description:
          type: string
        name:
          type: string
        required:
          type: boolean
        type:
          type: string
        values:
          type: array
          items:
            type: string
      required:
        - name
        - type
      title: HelpField
    HelpIo:
      type: object
      properties:
        fields:
          type: array
          items:
            $ref: '#/components/schemas/HelpField'
      required:
        - fields
      title: HelpIo
    HelpSdkMethod:
      type: object
      properties:
        language:
          type: string
        method:
          type: string
        package:
          type: string
      required:
        - language
        - method
      title: HelpSdkMethod
    HelpResponse:
      oneOf:
        - type: object
          properties:
            kind:
              type: string
              enum:
                - overview
              description: 'Discriminator value: overview'
            audience:
              $ref: >-
                #/components/schemas/HelpResponseDiscriminatorMappingOverviewAudience
            examples:
              type: array
              items:
                $ref: '#/components/schemas/HelpExample'
            next:
              type: array
              items:
                $ref: '#/components/schemas/HelpNextStep'
            summary:
              type: string
            topics:
              type: array
              items:
                $ref: '#/components/schemas/HelpTopic'
          required:
            - kind
            - summary
            - topics
          description: overview variant
        - type: object
          properties:
            kind:
              type: string
              enum:
                - topic
            aliases:
              type: array
              items:
                type: string
            api:
              $ref: '#/components/schemas/HelpApiOperation'
            audience:
              $ref: '#/components/schemas/HelpTopicResponseAudience'
            cli:
              $ref: '#/components/schemas/HelpCliCommand'
            examples:
              type: array
              items:
                $ref: '#/components/schemas/HelpExample'
            input:
              $ref: '#/components/schemas/HelpIo'
            next:
              type: array
              items:
                $ref: '#/components/schemas/HelpNextStep'
            output:
              $ref: '#/components/schemas/HelpIo'
            sdk:
              type: array
              items:
                $ref: '#/components/schemas/HelpSdkMethod'
            summary:
              type: string
            title:
              type: string
            topic:
              type: string
          required:
            - kind
            - summary
            - topic
          description: topic variant
      discriminator:
        propertyName: kind
      title: HelpResponse
    ErrorResponseReasonClass:
      type: string
      enum:
        - invalid_input
        - unauthorized
        - capability_denied
        - capability_limit_exceeded
        - rate_limited
        - not_found
        - conflict
        - upstream
        - server
      description: Stable public error category for programmatic branching.
      title: ErrorResponseReasonClass
    ErrorResponse:
      type: object
      properties:
        code:
          type: string
          description: >-
            Stable, dot-namespaced error code, e.g. "runtime.not_found" or
            "request.invalid".
        details:
          type: object
          additionalProperties:
            description: Any type
          description: >-
            Resource-specific structured context. Use `code` and `reasonClass`
            for branching.
        error:
          type: string
        hint:
          type: string
          description: Optional next action for recoverable errors, e.g. "retry after 2s".
        reasonClass:
          $ref: '#/components/schemas/ErrorResponseReasonClass'
          description: Stable public error category for programmatic branching.
        requestId:
          type: string
      required:
        - code
        - error
      title: ErrorResponse
  securitySchemes:
    bearerAuth:
      type: http
      scheme: bearer
      description: Use Bearer <api-key>.

```

## Examples



**Request**

```json
{}
```

**Response**

```json
{
  "kind": "overview",
  "summary": "This endpoint provides comprehensive help information for the bctrl API, SDK, and CLI. Use query parameters to specify the topic or audience for targeted help content.",
  "topics": [
    {
      "audiences": [
        "api",
        "sdk",
        "cli"
      ],
      "summary": "Details on how to authenticate with the bctrl API using API keys and tokens.",
      "title": "Authentication Help",
      "topic": "authentication",
      "aliases": [
        "auth",
        "authentication"
      ],
      "method": "GET",
      "operationId": "getAuthenticationHelp",
      "path": "/v1/help?topic=authentication"
    }
  ],
  "audience": "api",
  "examples": [
    {
      "audience": "api",
      "code": "curl -X GET 'https://api.bctrl.ai/v1/help?topic=authentication' -H 'Authorization: Bearer YOUR_API_KEY'",
      "command": "bctrl help authentication",
      "language": "bash",
      "request": {},
      "title": "Get help on authentication"
    }
  ],
  "next": [
    {
      "audience": "api",
      "command": "bctrl get-status",
      "method": "GET",
      "path": "/v1/status",
      "title": "Check API status",
      "topic": "status"
    }
  ]
}
```

**SDK Code**

```python
import requests

url = "https://api.bctrl.ai/v1/help"

payload = {}
headers = {
    "Authorization": "Bearer <token>",
    "Content-Type": "application/json"
}

response = requests.get(url, json=payload, headers=headers)

print(response.json())
```

```javascript
const url = 'https://api.bctrl.ai/v1/help';
const options = {
  method: 'GET',
  headers: {Authorization: 'Bearer <token>', 'Content-Type': 'application/json'},
  body: '{}'
};

try {
  const response = await fetch(url, options);
  const data = await response.json();
  console.log(data);
} catch (error) {
  console.error(error);
}
```

```go
package main

import (
	"fmt"
	"strings"
	"net/http"
	"io"
)

func main() {

	url := "https://api.bctrl.ai/v1/help"

	payload := strings.NewReader("{}")

	req, _ := http.NewRequest("GET", url, payload)

	req.Header.Add("Authorization", "Bearer <token>")
	req.Header.Add("Content-Type", "application/json")

	res, _ := http.DefaultClient.Do(req)

	defer res.Body.Close()
	body, _ := io.ReadAll(res.Body)

	fmt.Println(res)
	fmt.Println(string(body))

}
```

```ruby
require 'uri'
require 'net/http'

url = URI("https://api.bctrl.ai/v1/help")

http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true

request = Net::HTTP::Get.new(url)
request["Authorization"] = 'Bearer <token>'
request["Content-Type"] = 'application/json'
request.body = "{}"

response = http.request(request)
puts response.read_body
```

```java
import com.mashape.unirest.http.HttpResponse;
import com.mashape.unirest.http.Unirest;

HttpResponse<String> response = Unirest.get("https://api.bctrl.ai/v1/help")
  .header("Authorization", "Bearer <token>")
  .header("Content-Type", "application/json")
  .body("{}")
  .asString();
```

```php
<?php
require_once('vendor/autoload.php');

$client = new \GuzzleHttp\Client();

$response = $client->request('GET', 'https://api.bctrl.ai/v1/help', [
  'body' => '{}',
  'headers' => [
    'Authorization' => 'Bearer <token>',
    'Content-Type' => 'application/json',
  ],
]);

echo $response->getBody();
```

```csharp
using RestSharp;

var client = new RestClient("https://api.bctrl.ai/v1/help");
var request = new RestRequest(Method.GET);
request.AddHeader("Authorization", "Bearer <token>");
request.AddHeader("Content-Type", "application/json");
request.AddParameter("application/json", "{}", ParameterType.RequestBody);
IRestResponse response = client.Execute(request);
```

```swift
import Foundation

let headers = [
  "Authorization": "Bearer <token>",
  "Content-Type": "application/json"
]
let parameters = [] as [String : Any]

let postData = JSONSerialization.data(withJSONObject: parameters, options: [])

let request = NSMutableURLRequest(url: NSURL(string: "https://api.bctrl.ai/v1/help")! as URL,
                                        cachePolicy: .useProtocolCachePolicy,
                                    timeoutInterval: 10.0)
request.httpMethod = "GET"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data

let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
  if (error != nil) {
    print(error as Any)
  } else {
    let httpResponse = response as? HTTPURLResponse
    print(httpResponse)
  }
})

dataTask.resume()
```