# Rest API

**Decentralized API Workflow**

```mermaid
sequenceDiagram  
    participant User as User (dApp)  
    participant AgentGPT as AgentGPT Core  
    participant API as External REST API  
    participant SC as Settlement Contract  

    User->>AgentGPT: "Update CRM & Pay Vendor"  
    AgentGPT->>API: GET /crm/orders?status=unpaid (Signed)  
    API-->>AgentGPT: JSON Data + HMAC  
    AgentGPT->>AgentGPT: Validate & Build Tx  
    AgentGPT->>SC: executePayment(orderIds)  
    SC->>API: POST /payments (via Chainlink)  
    API-->>SC: 201 Created  
    SC-->>User: ERC-7641 Payment Receipt  
```

***

#### **1. API Gateway Configuration**

**Trusted Endpoints (YAML)**

```yaml
rest_integrations:  
  crm_system:  
    url: "https://api.agent-gpt.org/v2"  
    auth:  
      type: "jwt_bearer"  
      key_vault: "azure://crm-prod"  
    validation:  
      schema: "schemas/crm_order_v4.json"  
      blockchain_anchor:  
        interval: "1h"  
        contract: "0x891a..."  

  payment_gateway:  
    url: "https://dashboard.agent-gpt.org"  
    auth:  
      type: "oauth2_mtls"  
      credential_id: "payment-mtls-prod"  
    rate_limit:  
      rps: 25  
      burst: 100  
```

***

#### **2. Autonomous API Workflow**

**Self-Signed Request Handler (Python)**

```python
import requests  
from agentgpt.web3 import CredentialManager  

class APIAgent:  
    def __init__(self):  
        self.credentials = CredentialManager(chain="polygon")  

    async def fetch_and_pay_orders(self):  
        # Get authenticated session  
        session = self.credentials.get_signed_session("crm_system")  
        
        # Autonomous API call  
        response = await session.get(  
            "/crm/orders",  
            params={"status": "unpaid"},  
            headers={"X-Blockchain-Proof": "true"}  
        )  
        
        if response.status_code == 200:  
            payment_data = self._parse_orders(response.json())  
            tx_hash = await self.credentials.submit_transaction(  
                "PaymentContract",  
                "batchPay",  
                args=[payment_data]  
            )  
            return self._log_activity(tx_hash)  
```

***

#### **3. Blockchain-Verified API Contracts**

**Proof-of-Execution Contract (Solidity)**

```solidity
// contracts/APIVerifier.sol  
pragma solidity ^0.8.25;  

contract APIProof {  
    struct APIRequest {  
        bytes32 endpointHash;  
        bytes32 responseHash;  
        uint256 timestamp;  
    }  

    mapping(bytes32 => APIRequest) public proofs;  

    function logAPIInteraction(  
        string calldata endpoint,  
        string calldata response,  
        bytes calldata sig  
    ) external {  
        bytes32 requestId = keccak256(abi.encodePacked(endpoint, block.timestamp));  
        proofs[requestId] = APIRequest(  
            keccak256(bytes(endpoint)),  
            keccak256(bytes(response)),  
            block.timestamp  
        );  
        emit APILogged(requestId, sig);  
    }  
}  
```

***

#### **4. Performance Monitoring**

```bash
agentgpt monitor rest --group-by endpoint  
```

**Output**:

```
REAL-TIME API THROUGHPUT  
┌──────────────────────┬─────────┬───────────┬──────────────┐  
│ Endpoint             │ RPS     │ Avg Latency │ Cost (AGPT/hr) │  
├──────────────────────┼─────────┼───────────┼──────────────┤  
│ /crm/orders          │ 142     │ 238ms      │ 12.48        │  
│ /payments            │ 89      │ 417ms      │ 28.91        │  
│ /inventory           │ 67      │ 189ms      │ 9.12         │  
├──────────────────────┼─────────┼───────────┼──────────────┤  
│ TOTAL                │ 298 RPS │ 278ms      │ 50.51 AGPT   │  
└──────────────────────┴─────────┴───────────┴──────────────┘  
Success Rate: 99.3% | SLA Violations: 0.07%  
```

***

#### **5. Security Protocol**

**Request Signer (Rust)**

```rust
// agentgpt-signing/src/lib.rs  
pub fn sign_request(  
    method: &str,  
    path: &str,  
    body: &[u8],  
    private_key: &str  
) -> Result<String, SigningError> {  
    let message = format!("{}:{}:{}", method, path, hex::encode(body));  
    let sig = ecies::sign(private_key, message.as_bytes())  
        .map_err(|_| SigningError::CryptoFailure)?;  
    Ok(base64::encode(sig))  
}  
```

***

#### **Troubleshooting Matrix**

| **Issue**             | **Resolution Protocol**                                                |
| --------------------- | ---------------------------------------------------------------------- |
| 429 Too Many Requests | 1. Exponential backoff ▸ 2. Switch regions ▸ 3. Burn AGPT for priority |
| 504 Gateway Timeout   | 1. Verify Oracle liveliness ▸ 2. Re-route via IPFS                     |
| 401 Unauthorized      | 1. Rotate JWT via smart contract ▸ 2. Disable compromised nodes        |
| Data Schema Mismatch  | 1. Activate schema validator ▸ 2. Rollback API version                 |

***

#### **Best Practices**

1. **Schema Enforcement**:

```bash
agentgpt validate rest-schema \  
  --endpoint "/crm/orders" \  
  --version 2.4 \  
  --strict  
```

2. **Retry Policy Configuration**:

```yaml
retry_policies:  
  default:  
    attempts: 3  
    backoff: "exponential"  
    max_delay: "10s"  
  critical:  
    attempts: 5  
    backoff: "fibonacci"  
    conditions:  
      - "status >= 500"  
      - "network_error"  
```

3. **Circuit Breaker**:

```solidity
function triggerCircuitBreaker(address apiGateway) external {  
    require(failures[apiGateway] > 10, "Threshold not met");  
    status[apiGateway] = CircuitState.OPEN;  
    _scheduleReset(apiGateway);  
}  
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://agent-gpt.gitbook.io/agent-gpt/integration-examples/rest-api.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.