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

# Update Spending Limit

> Atualiza um limite de gastos existente. Permite modificar categoria, valor, período e status ativo. O usuário só pode atualizar seus próprios limites. Requer API key para autenticação e assinatura ativa.

<Note>
  Este endpoint permite atualizar um alerta de gastos existente, modificando categoria, valor, período ou status de ativação.
</Note>

## Descrição

O endpoint `PUT /tools/api/update-spending-limit` permite modificar os parâmetros de um alerta de gastos existente. Você pode atualizar um ou mais campos de cada vez.

## Autenticação

Este endpoint requer autenticação via Bearer token.

<ParamField header="Authorization" type="string" required>
  Bearer token com a API key do usuário. Formato: `Bearer sk-your-api-key-here`
</ParamField>

## Parâmetros de Query

<ParamField query="s" type="string" required="false">
  Parâmetro interno para indicar requisições via MCP. Use `s=s` para requisições MCP.
</ParamField>

## Body Parameters

<ParamField body="limitId" type="string" required>
  ID do alerta a ser atualizado
</ParamField>

<ParamField body="category" type="string" required="false">
  Nova categoria a ser monitorada
</ParamField>

<ParamField body="limitAmount" type="number" required="false">
  Novo valor limite em BRL. Deve ser um número positivo.
</ParamField>

<ParamField body="period" type="string" required="false">
  Novo período do alerta. Valores válidos: `daily`, `weekly`, `biweekly`, `monthly`
</ParamField>

<ParamField body="isActive" type="boolean" required="false">
  Define se o alerta está ativo ou não
</ParamField>

## Resposta

### Sucesso (200)

<ResponseExample>
  ```json Success theme={null}
  {
    "success": true,
    "data": {
      "id": "limit_123456789",
      "userId": "user_abc123",
      "category": "Alimentação",
      "limitAmount": 1200.00,
      "period": "monthly",
      "isActive": true,
      "isRecurring": false,
      "periodStart": null,
      "createdAt": "2024-10-15T10:30:00Z",
      "updatedAt": "2024-11-04T15:30:00Z"
    },
    "message": "Spending limit updated successfully",
    "timestamp": "2024-11-04T15:30:00Z"
  }
  ```
</ResponseExample>

### Erro de Validação (400)

<ResponseExample>
  ```json Error - Missing limitId theme={null}
  {
    "error": "Invalid or missing limitId",
    "message": "limitId must be a non-empty string"
  }
  ```

  ```json Error - No Updates theme={null}
  {
    "error": "No updates provided",
    "message": "At least one field must be provided for update"
  }
  ```

  ```json Error - Invalid Category theme={null}
  {
    "error": "Invalid category",
    "message": "category must be a non-empty string"
  }
  ```

  ```json Error - Invalid Amount theme={null}
  {
    "error": "Invalid limitAmount",
    "message": "limitAmount must be a positive number"
  }
  ```

  ```json Error - Invalid Period theme={null}
  {
    "error": "Invalid period",
    "message": "period must be one of: daily, weekly, monthly"
  }
  ```

  ```json Error - Invalid isActive theme={null}
  {
    "error": "Invalid isActive",
    "message": "isActive must be a boolean"
  }
  ```
</ResponseExample>

### Erro de Autenticação (401)

<ResponseExample>
  ```json Error theme={null}
  {
    "error": "Invalid or inactive API key",
    "message": "Please check your API key and try again",
    "type": "invalid_api_key"
  }
  ```
</ResponseExample>

### Erro - Alerta Não Encontrado (404)

<ResponseExample>
  ```json Error theme={null}
  {
    "error": "Spending limit not found",
    "message": "No spending limit found with ID: limit_123456789"
  }
  ```
</ResponseExample>

### Erro de Permissão (403)

<ResponseExample>
  ```json Error theme={null}
  {
    "error": "Access denied",
    "message": "You can only update your own spending limits"
  }
  ```
</ResponseExample>

## Campos da Resposta

<ResponseField name="success" type="boolean" required>
  Indica se a requisição foi bem-sucedida
</ResponseField>

<ResponseField name="data" type="object" required>
  Objeto com os dados atualizados do alerta

  <Expandable title="Updated Spending Limit Object">
    <ResponseField name="id" type="string" required>
      Identificador único do alerta
    </ResponseField>

    <ResponseField name="userId" type="string" required>
      ID do usuário proprietário do alerta
    </ResponseField>

    <ResponseField name="category" type="string" required>
      Categoria de gasto monitorada (atualizada)
    </ResponseField>

    <ResponseField name="limitAmount" type="number" required>
      Valor limite configurado em BRL (atualizado)
    </ResponseField>

    <ResponseField name="period" type="string" required>
      Período do alerta (atualizado)
    </ResponseField>

    <ResponseField name="isActive" type="boolean" required>
      Se o alerta está ativo (atualizado)
    </ResponseField>

    <ResponseField name="isRecurring" type="boolean" required>
      Se o alerta se renova automaticamente
    </ResponseField>

    <ResponseField name="periodStart" type="string">
      Data de início do período
    </ResponseField>

    <ResponseField name="createdAt" type="string" required>
      Data de criação original do alerta (ISO 8601)
    </ResponseField>

    <ResponseField name="updatedAt" type="string" required>
      Data da atualização (ISO 8601)
    </ResponseField>
  </Expandable>
</ResponseField>

<ResponseField name="message" type="string" required>
  Mensagem de confirmação da atualização
</ResponseField>

<ResponseField name="timestamp" type="string" required>
  Timestamp da requisição em formato ISO 8601
</ResponseField>

## Exemplos de Uso

### cURL

```bash theme={null}
# Atualizar apenas o valor limite
curl -X PUT 'https://www.pierre.finance/tools/api/update-spending-limit' \
  -H 'Authorization: Bearer sk-your-api-key-here' \
  -H 'Content-Type: application/json' \
  -d '{
    "limitId": "limit_123456789",
    "limitAmount": 1200
  }'

# Atualizar categoria e período
curl -X PUT 'https://www.pierre.finance/tools/api/update-spending-limit' \
  -H 'Authorization: Bearer sk-your-api-key-here' \
  -H 'Content-Type: application/json' \
  -d '{
    "limitId": "limit_123456789",
    "category": "Compras Online",
    "period": "weekly"
  }'

# Desativar um alerta
curl -X PUT 'https://www.pierre.finance/tools/api/update-spending-limit' \
  -H 'Authorization: Bearer sk-your-api-key-here' \
  -H 'Content-Type: application/json' \
  -d '{
    "limitId": "limit_123456789",
    "isActive": false
  }'
```

### JavaScript

```javascript theme={null}
const API_KEY = 'sk-your-api-key-here';
const BASE_URL = 'https://www.pierre.finance/tools/api';

async function updateSpendingLimit(limitId, updates) {
  const response = await fetch(`${BASE_URL}/update-spending-limit`, {
    method: 'PUT',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({ limitId, ...updates })
  });
  
  return await response.json();
}

// Exemplos de uso
updateSpendingLimit('limit_123', { limitAmount: 1200 });
updateSpendingLimit('limit_123', { category: 'Compras Online', period: 'weekly' });
updateSpendingLimit('limit_123', { isActive: false });
```

### Python

```python theme={null}
import requests

API_KEY = 'sk-your-api-key-here'
BASE_URL = 'https://www.pierre.finance/tools/api'

headers = {
    'Authorization': f'Bearer {API_KEY}',
    'Content-Type': 'application/json'
}

def update_spending_limit(limit_id, **updates):
    data = {'limitId': limit_id, **updates}
    response = requests.put(f'{BASE_URL}/update-spending-limit',
                          headers=headers, json=data)
    return response.json()

# Exemplos de uso
update_spending_limit('limit_123', limitAmount=1200)
update_spending_limit('limit_123', category='Compras Online', period='weekly')
update_spending_limit('limit_123', isActive=False)
```

## Códigos de Status

* `200`: Sucesso - Alerta atualizado
* `400`: Parâmetros inválidos ou nenhum campo para atualizar
* `401`: Erro de autenticação
* `403`: Acesso negado - alerta pertence a outro usuário
* `404`: Alerta não encontrado
* `500`: Erro interno do servidor

## Atualização Parcial

Este endpoint suporta atualização parcial - você pode enviar apenas os campos que deseja modificar. Os campos não incluídos no body permanecerão inalterados.

<Note>
  Ao atualizar um alerta, o campo `updatedAt` é automaticamente atualizado com o timestamp da modificação.
</Note>

<Warning>
  Você só pode atualizar alertas que pertencem ao seu usuário. Tentar atualizar alertas de outros usuários resultará em erro 403 (Access denied).
</Warning>

<Tip>
  Use `isActive: false` para pausar temporariamente um alerta sem deletá-lo. Isso é útil se você quiser reativá-lo depois.
</Tip>


## OpenAPI

````yaml PUT /tools/api/update-spending-limit
openapi: 3.1.0
info:
  title: Pierre Finance API
  description: >-
    API para acessar dados financeiros do Pierre Finance, incluindo contas,
    transações, parcelas e sincronização.
  version: v1.0.0
servers:
  - url: https://www.pierre.finance
security: []
tags:
  - name: Authentication
    description: API key management and authentication
  - name: Accounts
    description: Financial accounts management
  - name: Transactions
    description: Financial transactions
  - name: Installments
    description: Credit card installments and purchases
  - name: Bills
    description: Credit card bills and current bill summaries
  - name: Balance
    description: Account balance information
  - name: Closing Dates
    description: Credit card closing date management
  - name: Sync
    description: Account synchronization
  - name: Spending Limits
    description: Personal spending limits and alerts management
  - name: Payment Reminders
    description: Payment reminders management with WhatsApp and Email notifications
  - name: Analytics
    description: Financial analytics and insights
  - name: Memories
    description: User memory management for personalized AI interactions
  - name: Open Finance
    description: Open Finance connection and integration
paths:
  /tools/api/update-spending-limit:
    put:
      tags:
        - Spending Limits
      description: >-
        Atualiza um limite de gastos existente. Permite modificar categoria,
        valor, período e status ativo. O usuário só pode atualizar seus próprios
        limites. Requer API key para autenticação e assinatura ativa.
      operationId: updateSpendingLimit
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/UpdateSpendingLimitRequest'
      responses:
        '200':
          description: Limite de gastos atualizado com sucesso
          content:
            application/json:
              schema:
                type: object
                properties:
                  success:
                    type: boolean
                    example: true
                  data:
                    $ref: '#/components/schemas/SpendingLimit'
                  message:
                    type: string
                    example: Spending limit updated successfully
                  timestamp:
                    type: string
                    format: date-time
        '400':
          description: Parâmetros inválidos
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: Invalid or missing limitId
                  message:
                    type: string
        '401':
          $ref: '#/components/responses/AuthError'
        '403':
          description: Acesso negado
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: Access denied
                  message:
                    type: string
                    example: You can only update your own spending limits
        '404':
          description: Limite não encontrado
          content:
            application/json:
              schema:
                type: object
                properties:
                  error:
                    type: string
                    example: Spending limit not found
                  message:
                    type: string
        '500':
          $ref: '#/components/responses/ServerError'
      security:
        - BearerAuth: []
components:
  schemas:
    UpdateSpendingLimitRequest: {}
    SpendingLimit: {}
    AuthError: {}
    ServerError: {}
  responses:
    AuthError:
      description: Authentication or subscription error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/AuthError'
    ServerError:
      description: Internal server error
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ServerError'
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: string
      description: 'API key in Bearer token format. Example: Bearer sk-your-api-key-here'

````