> ## Documentation Index
> Fetch the complete documentation index at: https://docs.straddle.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Request and manage account capabilities

> Submit and track capability requests to enable specific features, processing limits, and payment types for your embedded Straddle accounts.

Capability Requests in Straddle allow you to enable specific features and functionalities for an account. Understanding how to manage capability requests is crucial for tailoring an account's abilities to meet business needs while ensuring compliance with regulatory requirements.

## Overview

Capability Requests serve several key purposes in the Straddle ecosystem:

1. **Feature Activation**: They allow accounts to access specific Straddle features and services.
2. **Compliance Management**: They ensure accounts only have access to capabilities they're approved for.
3. **Customization**: They enable tailoring of account functionalities to specific business needs.
4. **Risk Management**: They help Straddle manage risk by controlling access to certain features.

<CardGroup cols={2}>
  <Card title="Multiple Capabilities" icon="align-justify">
    Request multiple capabilities for an account to customize functionality
  </Card>

  <Card title="Status Tracking" icon="tractor">
    Track the status of capability requests throughout the approval process
  </Card>

  <Card title="Scalable Growth" icon="chart-line">
    Gradually expand account functionalities as business needs grow
  </Card>

  <Card title="Regulatory Compliance" icon="shield-check">
    Ensure compliance with regulatory requirements automatically
  </Card>
</CardGroup>

## Types of Capabilities

Straddle offers various capabilities that can be requested for an account. These are categorized into three main groups:

<ResponseField name="payment_types" type="object">
  <Expandable title="Payment Types">
    <ResponseField name="charges" type="object">
      Ability to process charges (accept payments).

      <Expandable title="Properties">
        <ResponseField name="capability_status" type="string">
          Can be 'active' or 'inactive'.
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="payouts" type="object">
      Ability to make payouts (send money).

      <Expandable title="Properties">
        <ResponseField name="capability_status" type="string">
          Can be 'active' or 'inactive'.
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="customer_types" type="object">
  <Expandable title="Customer Types">
    <ResponseField name="individuals" type="object">
      Ability to serve individual customers.

      <Expandable title="Properties">
        <ResponseField name="capability_status" type="string">
          Can be 'active' or 'inactive'.
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="businesses" type="object">
      Ability to serve business customers.

      <Expandable title="Properties">
        <ResponseField name="capability_status" type="string">
          Can be 'active' or 'inactive'.
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="consent_types" type="object">
  <Expandable title="Consent Types">
    <ResponseField name="signed_agreement" type="object">
      Ability to handle signed agreements.

      <Expandable title="Properties">
        <ResponseField name="capability_status" type="string">
          Can be 'active' or 'inactive'.
        </ResponseField>
      </Expandable>
    </ResponseField>

    <ResponseField name="internet" type="object">
      Ability to handle internet-based consent.

      <Expandable title="Properties">
        <ResponseField name="capability_status" type="string">
          Can be 'active' or 'inactive'.
        </ResponseField>
      </Expandable>
    </ResponseField>
  </Expandable>
</ResponseField>

## Creating a Capability Request

To request a new capability for an account, use the Create Capability Request endpoint.

### Attributes

When creating a capability request, you need to specify the following attributes:

| Field    | Type          | Description                                                                  |
| -------- | ------------- | ---------------------------------------------------------------------------- |
| type     | string (enum) | The specific type of capability being requested.                             |
| category | string (enum) | The category of the capability being requested.                              |
| settings | object        | Any specific settings or configurations needed for the requested capability. |

### Type Enum

<ResponseField name="type" type="enum">
  Possible values:

  <ul>
    <li><code>charges</code></li>
    <li><code>payouts</code></li>
    <li><code>individuals</code></li>
    <li><code>businesses</code></li>
    <li><code>signed\_agreement</code></li>
    <li><code>internet</code></li>
  </ul>
</ResponseField>

### Category Enum

<ResponseField name="category" type="enum">
  Possible values:

  <ul>
    <li><code>payment\_type</code></li>
    <li><code>customer\_type</code></li>
    <li><code>consent\_type</code></li>
  </ul>
</ResponseField>

### Example Request

Here's how you might create a new capability request:

<CodeGroup>
  ```bash theme={null}
  curl https://api.straddle.com/v1/accounts/acct_1234567890abcdef/capability_requests \
    -X POST \
    -H "Authorization: Bearer YOUR_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{
      "type": "charges",
      "category": "payment_type",
      "settings": {
        "max_transaction_amount": 10000,
        "currency": "USD"
      }
    }'
  ```

  ```javascript theme={null}
  async function createCapabilityRequest() {
    const res = await fetch('https://api.straddle.com/v1/accounts/acct_1234567890abcdef/capability_requests', {
      method: 'POST',
      headers: {
        'Authorization': 'Bearer YOUR_API_KEY',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        type: 'charges',
        category: 'payment_type',
        settings: {
          max_transaction_amount: 10000,
          currency: 'USD'
        }
      })
    })
    const json = await res.json()
    console.log(json)
  }
  ```
</CodeGroup>

## Capability Request Statuses

Capability requests go through different statuses as they are processed. Understanding these statuses is crucial for managing capability requests effectively.

### Status Enum

<ResponseField name="status" type="enum">
  Possible values:

  <ul>
    <li><code>approved</code>: The capability request has been approved and the capability is now active.</li>
    <li><code>rejected</code>: The capability request has been rejected.</li>
    <li><code>reviewing</code>: The capability request is currently under review.</li>
  </ul>
</ResponseField>

## Managing Capability Requests

Once you've submitted a capability request, you can check its status and retrieve details about it.

### Retrieving Capability Request Details

To view the details of a specific capability request, use the Get Capability Request endpoint

#### Example Request

<CodeGroup>
  ```bash theme={null}
  curl https://api.straddle.com/v1/accounts/acct_1234567890abcdef/capability_requests/cap_req_9876543210fedcba \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```javascript theme={null}
  async function getCapabilityRequest() {
    const res = await fetch('https://api.straddle.com/v1/accounts/acct_1234567890abcdef/capability_requests/cap_req_9876543210fedcba', {
      headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
    })
    const json = await res.json()
    console.log(json)
  }
  ```
</CodeGroup>

### Listing Capability Requests

You can retrieve a list of all capability requests for an account using the List Capability Requests endpoint.

#### Example Request

<CodeGroup>
  ```bash theme={null}
  curl https://api.straddle.com/v1/accounts/acct_1234567890abcdef/capability_requests \
    -H "Authorization: Bearer YOUR_API_KEY"
  ```

  ```javascript theme={null}
  async function listCapabilityRequests() {
    const res = await fetch('https://api.straddle.com/v1/accounts/acct_1234567890abcdef/capability_requests', {
      headers: { 'Authorization': 'Bearer YOUR_API_KEY' }
    })
    const json = await res.json()
    console.log(json)
  }
  ```
</CodeGroup>

## Best Practices

When working with capability requests in Straddle, consider the following best practices:

<AccordionGroup>
  <Accordion title="Be Strategic" icon="chess-queen">
    Only request capabilities that are necessary for your current business operations. You can always request additional capabilities as your needs grow.
  </Accordion>

  <Accordion title="Prepare Documentation" icon="clipboard-check">
    Requests for high-ticket payment limits might require additional documentation.
  </Accordion>

  <Accordion title="Allow Processing Time" icon="hourglass-half">
    Some capability requests may require manual review. Factor this into your timelines when planning new feature rollouts.
  </Accordion>

  <Accordion title="Handle Rejections Gracefully" icon="rotate">
    If a capability request is rejected, review the reason carefully. You may need to provide additional information or adjust your business processes before reapplying.
  </Accordion>
</AccordionGroup>

## Handling Capability Request Outcomes

Different outcomes of capability requests require different actions:

### Approved Requests

When a capability request is approved:

1. Update your systems to reflect the new capability.
2. Inform the account holder about the new capability and any associated responsibilities.
3. Ensure your integration is ready to use the new capability.

### Reviewing Requests

While a request is under review:

1. Monitor the request status regularly.
2. Be prepared to provide additional information if requested by Straddle.
3. Avoid making duplicate requests for the same capability.

### Rejected Requests

If a capability request is rejected:

1. Review the rejection reason carefully.
2. Address any issues or concerns mentioned in the rejection.
3. Consider if you need to adjust your business model or processes.
4. If appropriate, prepare a new request with additional information or changes.

<Info>
  Capability management is an ongoing process. Regularly review your account's capabilities to ensure they align with your current business needs and compliance requirements.
</Info>