Name: Python Data Type Optimizer API | Reduce Cloud Costs 30-75%
Brand: winter-hazel-inc
SKU: api-winter-hazel-inc-slimdata
Availability: InStock
Author: API Market

Aamir Qadeer

# slimdata API

## Overview

slimdata is a Python data type optimization API that reduces memory usage, shrinks storage costs, and speeds up applications — without rewriting a single line of business logic. One API call returns a full savings report in bytes, KB, MB, or GB.

Real World Savings:
- Integer list: 80 bytes reduced to 20 bytes — 75% reduction
- Float list: 40 bytes reduced to 20 bytes — 50% reduction
- Sparse matrix 88% zeros: 200 bytes reduced to 48 bytes — 76% reduction
- Six boolean variables: 168 bytes reduced to 28 bytes — 83% reduction
- Large 1GB file: memory reduced to accessed bytes only — up to 99% reduction
- Cloud bill: $100/month reduced to $25-70/month — 30-75% savings

---

## Features

- 17 Optimization Capabilities — Core optimization, advanced analysis, and database schema advisor in one API.
- 12 Core Optimizations — Downcast numeric types, convert to categorical, native arrays, remove duplicates, flatten nested structures, and more.
- 5 Advanced Analysis Tools — Memory leak detector, sparse matrix optimizer, generator advisor, bitwise flag optimizer, and memory mapper.
- 7 Database Advisors — PostgreSQL, MySQL, SQLite, MongoDB, SQL Server, Amazon RDS, and Google BigQuery.
- Instant Savings Report — Every response includes original size, optimized size, and exact bytes saved.
- Zero Code Rewrites — slimdata only analyzes and recommends. Your code and database are never modified.
- MCP Compatible — Works with Claude Code, Cursor, Windsurf, and any MCP-compatible AI client.

---

## Use Cases

- Reduce AWS and Google Cloud bills — Optimize database column types and save 30-75% on monthly storage costs.
- Speed up Python applications — Downcast numeric data types to reduce memory footprint instantly.
- Detect memory leaks — Scan Python code before deployment to prevent application crashes.
- Optimize machine learning pipelines — Compress sparse matrices from 8MB to under 1MB.
- Handle large files efficiently — Use memory mapping to process 1GB files without loading them into RAM.
- Clean database schemas — Scan all 7 supported databases and get actionable column type recommendations.

---

## Base URL

All API requests for slimdata should be made to the following base URL:

https://prod.api.market/v1/winter-hazel-inc/slimdata

---

## Authentication

Authentication is handled via an API key. You must include your key in the x-magicapi-key header of every request:

x-magicapi-key: YOUR_API_KEY

Replace YOUR_API_KEY with your actual API key.

---

## Endpoints

### 1. Optimize Data

Optimizes a single Python data structure and returns a savings report.

Method: POST
Endpoint: /optimize

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| data | body | Python data structure to optimize | array or object | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/optimize" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"data": [1000, 2000, 3000, 4000, 5000]}'
```

Example Response (200 OK):
```json
{
  "status": "success",
  "result": {
    "optimized": [1000, 2000, 3000, 4000, 5000],
    "savings": {
      "original_type": "list",
      "optimized_type": "array.h",
      "original_size": 40,
      "optimized_size": 10,
      "saved": "30 bytes"
    }
  }
}
```

---

### 2. Optimize Batch

Optimizes multiple Python data structures in a single API call.

Method: POST
Endpoint: /optimize/batch

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| data_list | body | List of Python data structures to optimize | array | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/optimize/batch" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"data_list": [[1000, 2000, 3000], [1.5, 2.5, 3.5]]}'
```

Example Response (200 OK):
```json
{
  "status": "success",
  "results": [
    {"optimized": [1000, 2000, 3000], "savings": {"original_type": "list", "optimized_type": "array.h", "saved": "18 bytes"}},
    {"optimized": [1.5, 2.5, 3.5], "savings": {"original_type": "list", "optimized_type": "array.f", "saved": "12 bytes"}}
  ]
}
```

---

### 3. Optimize Structural

Optimizes structural patterns in Python data. Detects duplicates, converts lists to tuples, removes empty containers.

Method: POST
Endpoint: /optimize/structural

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| data | body | Python data structure to optimize structurally | array or object | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/optimize/structural" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"data": ["hello", "world", "hello", "python"]}'
```

Example Response (200 OK):
```json
{
  "original_type": "list",
  "optimized_type": "list",
  "pattern_applied": "duplicates_removed",
  "original_size": 120,
  "optimized_size": 88,
  "saved": "32 bytes",
  "optimized": ["hello", "world", "python"]
}
```

---

### 4. Optimize Structural Batch

Optimizes multiple Python data structures for structural patterns in a single API call.

Method: POST
Endpoint: /optimize/structural/batch

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| data_list | body | List of Python data structures to optimize structurally | array | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/optimize/structural/batch" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"data_list": [["hello", "world", "hello"], [1, 2, 3, 4, 5]]}'
```

---

### 5. Optimize Sparse Matrix

Detects sparse matrices with over 70% zero values and compresses them to CSR format.

Method: POST
Endpoint: /optimize/sparsematrix

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| matrix | body | Matrix to compress | array | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/optimize/sparsematrix" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"matrix": [[0,0,0,5],[0,0,0,0],[0,3,0,0],[0,0,0,0]]}'
```

Example Response (200 OK):
```json
{
  "status": "optimized",
  "sparsity_ratio": 87.5,
  "original_format": "dense matrix",
  "optimized_format": "CSR sparse matrix",
  "original_size": 128,
  "optimized_size": 32,
  "saved": "96 bytes"
}
```

---

### 6. Optimize Sparse Matrix Batch

Optimizes multiple sparse matrices in a single API call.

Method: POST
Endpoint: /optimize/sparsematrix/batch

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| matrices | body | List of matrices to compress | array | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/optimize/sparsematrix/batch" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"matrices": [[[0,0,0,5],[0,0,0,0],[0,3,0,0],[0,0,0,0]]]}'
```

---

### 7. Analyze Memory Leaks

Scans Python code and detects memory leaks. Reports line numbers and severity levels — high, medium, low.

Method: POST
Endpoint: /analyze/memoryleak

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| code | body | Python code to scan for memory leaks | string | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/analyze/memoryleak" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"code": "logs = []\ndef add_log(msg):\n    logs.append(msg)"}'
```

Example Response (200 OK):
```json
{
  "status": "success",
  "total_leaks_found": 2,
  "severity": {"high": 1, "medium": 1, "low": 0},
  "leaks": [
    {
      "type": "global_list",
      "variable": "logs",
      "line": 1,
      "description": "Global list that grows indefinitely",
      "recommendation": "Move logs inside a function or class. Clear it periodically."
    }
  ],
  "summary": "Found 2 potential memory leaks. 1 high severity, 1 medium severity."
}
```

---

### 8. Generator Advisor

Scans Python code for list comprehensions and recommends generator expressions to save memory.

Method: POST
Endpoint: /analyze/generatoradvisor

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| code | body | Python code to analyze | string | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/analyze/generatoradvisor" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"code": "squares = [x * x for x in range(1000000)]"}'
```

Example Response (200 OK):
```json
{
  "status": "success",
  "total_recommendations": 1,
  "recommendations": [
    {
      "type": "list_comprehension",
      "line": 1,
      "example_before": "[x for x in data]",
      "example_after": "(x for x in data)",
      "memory_impact": "High — saves memory proportional to data size"
    }
  ]
}
```

---

### 9. Bitwise Optimizer

Detects multiple boolean variables and recommends combining them into a single integer using bitwise flags. Saves up to 83% memory.

Method: POST
Endpoint: /analyze/bitwiseoptimizer

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| code | body | Python code to analyze for boolean variables | string | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/analyze/bitwiseoptimizer" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"code": "is_active = True\nis_admin = False\nis_verified = True\nis_premium = False\nhas_access = True\ncan_edit = False"}'
```

Example Response (200 OK):
```json
{
  "status": "success",
  "total_recommendations": 1,
  "savings": {
    "boolean_count": 6,
    "original_size": 168,
    "optimized_size": 28,
    "saved": "140 bytes"
  }
}
```

---

### 10. Memory Mapper

Analyzes Python code for large file operations and recommends memory mapping techniques. Saves up to 990MB on 1GB files.

Method: POST
Endpoint: /analyze/memorymapper

Parameters:

| Name | In | Description | Type | Required |
|---|---|---|---|---|
| code | body | Python code to analyze for file operations | string | Yes |

Example Request:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/analyze/memorymapper" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"code": "file = open(\"large_data.bin\", \"rb\")\ndata = file.read()"}'
```

Example Response (200 OK):
```json
{
  "status": "success",
  "total_recommendations": 1,
  "recommendations": [
    {
      "type": "file_open",
      "line": 1,
      "recommendation": "Use mmap for large files to avoid loading entire file into memory.",
      "memory_impact": "High — reads only required bytes instead of entire file"
    }
  ]
}
```

---

### 11. Database Advisors

Connect directly to your database and scan every table and column for oversized data types. Returns exact recommendations with bytes saved per row.

Supported Databases and Endpoints:

| Database | Method | Endpoint |
|---|---|---|
| PostgreSQL | POST | /database/postgresql |
| MySQL | POST | /database/mysql |
| SQLite | POST | /database/sqlite |
| MongoDB | POST | /database/mongodb |
| SQL Server | POST | /database/sqlserver |
| Amazon RDS | POST | /database/amazonrds |
| Google BigQuery | POST | /database/bigquery |

Database Recommendations:
- PostgreSQL — TINYINT, SMALLINT over BIGINT
- MySQL — INT, FLOAT, VARCHAR over BIGINT, DOUBLE, LONGTEXT
- SQLite — BLOB over TEXT for binary data
- MongoDB — Float over Double, TINYINT over Int64
- SQL Server — INT, VARCHAR over BIGINT, NVARCHAR
- Amazon RDS — supports MySQL and PostgreSQL engines
- Google BigQuery — INT32, FLOAT32 over INT64, FLOAT64

Example Request — SQLite:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/database/sqlite" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"db_path": "/path/to/your/database.db"}'
```

Example Response (200 OK):
```json
{
  "status": "success",
  "recommendations": {
    "users": [
      {
        "column": "age",
        "current_type": "BIGINT",
        "recommended_type": "INT",
        "saved": "4 bytes per row"
      }
    ]
  }
}
```

Example Request — PostgreSQL:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/database/postgresql" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"connection_string": "host=your_host dbname=your_database user=your_user password=your_password port=5432"}'
```

Example Request — MySQL:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/database/mysql" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"host": "your_host", "user": "your_user", "password": "your_password", "database": "your_database", "port": 3306}'
```

Example Request — MongoDB:
```
curl -X POST "https://prod.api.market/v1/winter-hazel-inc/slimdata/database/mongodb" \
-H "x-magicapi-key: YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"connection_string": "mongodb+srv://user:password@cluster.mongodb.net/", "database": "your_database"}'
```

---

## Status Codes

| Code | Status | Description |
|---|---|---|
| 200 | OK | The request succeeded and data has been returned. |
| 400 | Bad Request | The request contains invalid parameters or a malformed body. |
| 401 | Unauthorized | The x-magicapi-key header is missing or contains an invalid key. |
| 403 | Forbidden | Your API key is valid but lacks permission to access this resource. |
| 404 | Not Found | The requested endpoint does not exist. Verify the URL path. |
| 422 | Unprocessable Entity | The request body is malformed or missing required fields. |
| 429 | Too Many Requests | You have exceeded the rate limit. Implement exponential backoff. |
| 500 | Internal Server Error | An unexpected server error occurred. Retry after a brief delay. |

---

## Rate Limits

| Plan | Requests per Month | Rate Limit per Minute |
|---|---|---|
| Basic | 500 | 10 |
| Pro | 2,000 | 20 |
| Biz | 10,000 | 50 |
| Flex | Pay as you go | 10 |

If the rate limit is exceeded the API returns a 429 Too Many Requests response. Implement client-side throttling and exponential backoff in your application.

---

## FAQ

**What Python data structures can slimdata optimize?**

A: slimdata optimizes lists, arrays, dictionaries, sets, tuples, pandas DataFrames, numpy arrays, and sparse matrices.

**Will slimdata modify my code or database?**

A: No. slimdata only analyzes and recommends. It never modifies your code or database directly. You receive a detailed report showing exactly what to change.

**Which databases does slimdata support?**

A: slimdata supports PostgreSQL, MySQL, SQLite, MongoDB, Microsoft SQL Server, Amazon RDS, and Google BigQuery.

**How much can slimdata reduce my cloud bills?**

A: Based on real optimization results slimdata reduces storage by 30-75% which typically cuts Google Cloud and AWS monthly bills from $100 to $25-70 per month.

**Is slimdata MCP compatible?**

A: Yes. slimdata works with Claude Code, Cursor, Windsurf, Cline, and any MCP-compatible AI client.

**Does slimdata store my code or data?**

A: No. Your source code and data are never stored on our servers. All processing happens in memory and results are returned immediately.

---

## Contact

Built and maintained by Winter Hazel Inc. Canada.
Website: https://winterhazel.net
Email: support@winterhazel.net


The slimdata API optimizes Python data types and database schemas, reducing memory usage, cutting storage costs by 30-75%, and speeding up apps with zero code r

Python Data Type Optimizer API | Reduce Cloud Costs 30-75%