# Create Silo
Source: https://docs.jsonsilo.com/api-reference/endpoint/create-silo
POST /api/v1/manage/
API endpoint to create a new silo
# Delete Silo
Source: https://docs.jsonsilo.com/api-reference/endpoint/delete-silo
DELETE /api/v1/manage/{file_uuid}
API endpoint to delete a silo
# Get Silo Meta
Source: https://docs.jsonsilo.com/api-reference/endpoint/get-meta
GET /api/v1/manage/meta/{file_uuid}
API endpoint to retrieve the metadata of a silo.
# Get Silo
Source: https://docs.jsonsilo.com/api-reference/endpoint/get-silo
GET /api/v1/manage/{file_uuid}
API endpoint to retrieve silo data.
# Get Silo List
Source: https://docs.jsonsilo.com/api-reference/endpoint/get-silo-list
GET /api/v1/manage/silos
API endpoint to list all user silos with pagination.
# Update Silo
Source: https://docs.jsonsilo.com/api-reference/endpoint/patch-silo
PATCH /api/v1/manage/{file_uuid}
API endpoint to update silo.
> ⚠️ **Warning**
>
> * This update process does not happen in real-time. It's not suitable for scenarios where **multiple users attempt to update data simultaneously**.
***
# Introduction
Source: https://docs.jsonsilo.com/api-reference/introduction
Understand general concepts, response codes, and authentication strategies.
## JSONSilo Manage API
The JSONSilo Manage API allows you to programmatically manage your JSON silos, including creating, updating, deleting silos, and managing files within those silos.
### Base URL
The base URL for the JSONSilo Manage API is structured as follows:
```bash theme={null}
https://[region-code].jsonsilo.com/api/v1/manage/
```
> Replace `[region-code]` with the appropriate region code for your silo, and `[file-uuid]` with the unique identifier assigned to your JSON file.
>
> * [Retrieving your file uuid and region code](/quick-start#retrieving-your-file-uuid-and-region-code)
### Endpoints
The JSONSilo Manage API provides the following endpoints:
| Endpoint | Method | Description |
| ------------------- | -------- | ---------------------------------------------------------------------------- |
| `/` | `POST` | [Create a new silo](/api-reference/endpoint/create-silo) |
| `/{file_uuid}` | `DELETE` | [Delete a specific silo](/api-reference/endpoint/delete-silo) |
| `/meta/{file_uuid}` | `GET` | [Retrieve metadata for a specific silo](/api-reference/endpoint/get-meta) |
| `/{file_uuid}` | `GET` | [Retrieve `file_data` for a specific silo](/api-reference/endpoint/get-silo) |
| `/silos` | `GET` | [List all silos](/api-reference/endpoint/get-silo-list) |
| `/{file_uuid}` | `PATCH` | [Update a specific silo](/api-reference/endpoint/patch-silo) |
### Authentication
To use the JSONSilo Manage API, you need an API key for authentication. Include your API key in the `X-MAN-API` or `x-man-api` HTTP header for all API requests:
```bash theme={null}
X-MAN-API: MANAGE_API_KEY
```
> * Replace `MANAGE_API_KEY` with your actual API key.
> * To generate a new API key, follow the instructions [here](/keys/manage-keys).
#### Example Request
Here is an example of how to make a request using `curl`:
```bash Terminal theme={null}
curl -X GET "https://api.jsonsilo.com/api/v1/manage/silos" \
-H "X-MAN-API: YOUR_MANAGE_API_KEY" \
-H "Content-Type: application/json"
```
# Cancel Subscription
Source: https://docs.jsonsilo.com/billing/cancel-subscription
Guide on how to cancel your subscription plan.
## Introduction
This guide provides step-by-step instructions on how to cancel your subscription plan in JSONsilo.
Click on the "Billing" menu in the sidebar to view your billing details.
Click the `Manage Subscription` button and click `Cancel Subscription` in the dropdown menu.
A dialog will appear to confirm your cancellation. Follow the prompts to complete the cancellation process.
# Change Plan
Source: https://docs.jsonsilo.com/billing/upgrade-plan
Guide on how to change your subscription plan.
## Introduction
This guide provides step-by-step instructions on how to change your subscription plan in JSONsilo.
Click on the "Billing" menu in the sidebar to view your billing details.
Click the `Manage Subscription` button and select `Change Plan` from the dropdown menu.
A dialog will appear showing the available plans. Select the desired plan and follow the prompts to complete the change.
# Update
Source: https://docs.jsonsilo.com/changelog/update
Latest feature updates on JSONsilo.com:
### Update & Fix
* **\[New]** Query & Search API endpoint for enhanced data retrieval.
* **\[New]** Rate Limiting to ensure fair usage and system stability.
* **\[New]** Updated UI for better usability and aesthetics.
* **\[New]** Live Chat Support for real-time assistance.
* **\[New]** Introduced Basic plan (\$9) and removed Pro+ plan.
* **\[Improved]** Increased Pro plan silo storage capacity from 5MB to 10MB.
* **\[Improved]** Overall system stability and user experience.
* **\[Fixed]** Bug fixes and performance improvements.
### Update & Fix
* Enforced rate limiting to improve system stability.
* Increased Pro plan silo storage capacity from 5MB to 10MB.
* Resolved an issue with the cache pool to enhance performance.
* **NEW**: Introduced Silo Query & Search functionality for better data retrieval.
### Update & Fix
* UI fixed
* Fixed minor bug
### New logo

### UI Update
Here’s a sneak peek at the new UI update—now with full support for dark mode!

### Bug Fixes
* Improved cache and database to handle larger requests.
* Fixed the dashboard session issue—users can now stay on the dashboard without unexpected timeouts.
* ...and more!
### New Region
We’ve added a brand-new server region to provide even better coverage:
* Region: US Central
* Region code: usc-01-api
### Added New Plans
We’ve introduced new plans to suit your needs :
### Pro Plan - \$25/month
* Store up to 5MB per silo
* 110 silos (+1 free) = 111 silos \[Update]
### Pro+ Plan - \$45/month
* Store up to 20MB per silo
* 110 silos (+1 free) = 111 silos
# Billing
Source: https://docs.jsonsilo.com/faq/billing
Frequently Asked Questions about JSONsilo billing
We accept all major credit cards, Apple Pay, and Google Pay.
No, JSONsilo is committed to transparency. The price you see is the price you pay, with no hidden fees or surprises.
You can update your billing information by logging into your account and navigating to the billing section. From there, you can edit your payment details.
We offer a 7-day money-back guarantee for all new customers. If you're not satisfied with our service, you can request a full refund within 7 days of signing up.
# General
Source: https://docs.jsonsilo.com/faq/general
Frequently Asked Questions about JSONsilo
JSONsilo is a fast and simple cloud-based storage solution that instantly turns your JSON data into a secure, shareable API. Whether you're prototyping, testing, or building a production-ready app, JSONsilo lets you store and retrieve structured data effortlessly.
To create an account, visit our [Sign Up Page](https://jsonsilo.com/signup) and fill out the registration form with your details. Once submitted, you'll receive a confirmation email to verify your account.
JSONsilo offers features such as public and private JSON data, powerful search and query data in JSON.
If you need assistance, you can reach out to our support team via the email [hello@jsonsilo.com](mailto:hello@jsonsilo.com) or chat with us directly through the support widget on our website.
Our comprehensive documentation is available on our [Documentation Page](https://docs.jsonsilo.com), where you can find guides, API references, and tutorials to help you get started.
# Query
Source: https://docs.jsonsilo.com/features/query-silo-data
Dynamically query silo data
## Introduction
JSONsilo now supports querying data from silos. This feature lets you dynamically retrieve and interact with silo data programmatically. By appending specific query parameters to your silo URL, you can extract precise information from your JSON data without needing to download or manually parse the entire dataset.
> **This feature is currently supported only for Private Silos.**
## Limitations
While the query functionality is a powerful feature, it is still in its early stages and has some limitations:
* Selecting specific indices or ranges based on index is limited.
* Query performance may vary depending on the size and complexity of the silo data.
* Only private silos are supported; public silos are not yet supported.
# Usage
Below are the available query parameters you can use:
> **Note:** Ensure the parameters are in the correct order when combining them in a single request.
* `idx`: Specifies the index of the item to retrieve.
* `path`: Specifies the path to a specific field within the JSON data.
* `output`: Specifies the desired output format or data type.
## Parameters
### `idx`
The `idx` parameter stands for "index" and is used to retrieve a specific item from an array in your silo data. It is helpful when your silo data is an array of objects, and you want to access an object based on its position in the array.
#### How It Works
Suppose your silo data looks like this:
```json data.json theme={null}
[
{ "name": "John Doe", "age": 58 },
{ "name": "Elon Musk", "age": 50 }
]
```
You can use the `idx` parameter to specify which object you want to retrieve by its index (starting from `0`).
To get the first object in the array (John Doe), you would use:
```bash theme={null}
?idx=0
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?idx=0
```
Response:
```json theme={null}
{
"name": "John Doe",
"age": 58
}
```
> **Note:**
>
> * If you use `idx` on non-array data, the result will be `null`.
> * You can combine the `idx` parameter with the `path` parameter for more advanced queries.
***
### `path`
The `path` parameter lets you specify a path within the silo data to retrieve specific fields or nested data. This is useful for working with complex JSON structures that contain objects, arrays, or both.
#### How It Works
The `path` parameter uses dot notation to navigate through the JSON structure. Each segment separated by a dot (`.`) represents a key or index in the JSON object or array.
Suppose your silo data looks like this:
```json data.json theme={null}
{
"config": {
"backup": {
"enabled": true,
"maxBackups": 5,
"backupLocation": "/user/data/backups/"
},
"format": "json",
"autosave": true,
"filePath": "/user/data/saves/",
"compression": false,
"saveInterval": 300
}
}
```
#### Retrieving a Specific Field
To retrieve a specific field, you provide the path to that field using dot (`.`) notation.
To retrieve the value of the `filePath` field, use the following URL:
```bash theme={null}
?path=config.filePath
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?path=config.filePath
```
Response:
```bash theme={null}
"/user/data/saves/"
```
#### Retrieving a Nested Object
If you want to retrieve an entire nested object, you can specify the path to that object.
To retrieve the entire `backup` object, use:
```bash theme={null}
?path=config.backup
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?path=config.backup
```
Response:
```json theme={null}
{
"enabled": true,
"maxBackups": 5,
"backupLocation": "/user/data/backups/"
}
```
#### Accessing Array Elements
If your `data.json` contains arrays, you can use numeric indices in the path.
For example:
```json data.json theme={null}
{
"users": [
{ "name": "Li Ming", "role": "admin" },
{ "name": "Bob", "role": "user" }
]
}
```
To retrieve the name of the first user:
```bash theme={null}
?path=users.0.name
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?path=users.0.name
```
Response:
```text theme={null}
"Li Ming"
```
> #### Notes
>
> * The `path` parameter is case-sensitive and must match the exact structure of your data.
> * If the specified path does not exist, the response will be `null` or return an error.
> * You can combine the `path` parameter with other parameters (such as `idx` and `output`) for more advanced queries.
### `output`
This parameter won't work without the `idx` and `path` parameters.
The `output` parameter lets you choose the format or data type of the response. By default, the API returns data in `json` format, but you can use the `output` parameter to convert the result to a format that fits your needs.
#### How It Works
Suppose your silo data looks like this:
```json data.json theme={null}
{
"backup": {
"enabled": true,
"maxBackups": "5",
"backupLocation": "/user/data/backups/"
}
}
```
To retrieve the value of `backup.enabled` as its default type (boolean), you would use:
```bash theme={null}
?path=backup.enabled
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?path=backup.enabled
```
Response:
```text theme={null}
true
```
To convert the value of `backup.enabled` to a string, you would use:
```bash theme={null}
?path=backup.enabled&output=text
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?path=backup.enabled&output=text
```
Response:
```text theme={null}
"true"
```
***
To retrieve the value of `backup.maxBackups` as its default type (string), you would use:
```bash theme={null}
?path=backup.maxBackups
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?path=backup.maxBackups
```
Response:
```text theme={null}
"5"
```
To convert the value of `backup.maxBackups` to an integer, you would use:
```bash theme={null}
?path=backup.maxBackups&output=int
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?path=backup.maxBackups&output=int
```
Response:
```text theme={null}
5
```
#### Supported Output Types
| Output Type | Description |
| ----------- | ------------------------------------------------------------ |
| `text` | Converts the result to a plain text string. |
| `int` | Converts the result to an integer, if possible. |
| `float` | Converts the result to a floating-point number, if possible. |
| `bool` | Converts the result to a boolean value. |
| `date` | `Not supported` |
| `timestamp` | `Not supported` |
> **Notes:**
>
> * If the conversion is not possible (e.g., converting a non-numeric string to `int`), the API will return an error or `null`.
> * The `output` parameter can be combined with `path` and `idx` for advanced queries.
> * Ensure the data at the specified path is compatible with the requested output type.
***
### Combining `idx` and `path` Parameters
You can combine the `idx` and `path` parameters to perform detailed queries on array-based JSON data. This is useful for selecting a specific item from an array and extracting a particular field from that item.
#### How It Works
Suppose your silo data looks like this:
```json data.json theme={null}
[
{
"name": "John Doe",
"age": 58,
"contacts": {
"email": "john@example.com"
}
},
{
"name": "Jairon Landa",
"age": 29,
"contacts": {
"email": "jairon@example.com"
}
},
{
"name": "Elon Musk",
"age": 50,
"contacts": {
"email": "elon@example.com"
}
}
]
```
#### Combine `idx` and `path`
You can combine the `idx` and `path` parameters to perform detailed queries on array-based JSON data. This is useful for selecting a specific item from an array and extracting a particular field from that item.
#### Basic Example
Suppose you want to retrieve the `name` field from the object at index `1`:
* Use `?idx=1` to select the second object in the array.
* Use `&path=name` to extract the `name` field from that object.
```bash theme={null}
?idx=1&path=name
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?idx=1&path=name
```
Response:
```text theme={null}
"Jairon Landa"
```
#### Advanced Example: Nested Fields
Suppose you want to retrieve a nested field, such as the `email` from the `contacts` object of the user at index `2`.
* Use `?idx=2` to select the third object in the array.
* Use `&path=contacts.email` to extract the `email` field from that object.
```bash theme={null}
?idx=2&path=contacts.email
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?idx=2&path=contacts.email
```
Response:
```text theme={null}
"elon@example.com"
```
> **Notes:**
>
> * If the specified `idx` or `path` does not exist, the API will return `null`.
> * The `path` parameter is case-sensitive and must match the exact structure of your data.
> * You can combine `idx`, `path`, and `output` for advanced queries, such as converting the result to a specific type.
> * **Example**: `?idx=2&path=contacts.age&output=text`
> * **Output**: `"50"` (convert int to text)
# Search
Source: https://docs.jsonsilo.com/features/search-silo-data
Dynamically search silo data
## Introduction
JSONsilo now supports searching data within silos. This feature allows you to search and interact with silo data programmatically. By adding specific search query parameters to your silo URL, you can search for precise information within your JSON data without needing to download or manually parse the entire dataset.
> **This feature is currently supported only for Private Silos.**
## Limitations
While the search feature is powerful, it currently has some limitations:
* Only private silos are supported; public silos are not yet available.
* `output` parameter is not supported in search functionality.
Future updates will add support for more complex queries, additional operators, sorting, and pagination.
# Usage
To search data from your private silo, you need to add specific query parameters to your silo URL. These parameters allow you to retrieve data dynamically based on your requirements.
> **Notes:**
>
> * Make sure the parameters are in the correct order when combining them in a request.
> * All parameters are required for the search to work.
> * Default operator is `eq` (equal to) if not specified.
> * Default response format is Array of Objects.
* `q`: The path in the silo data to search.
* `value`: The value to search for at the specified path.
* `op`: The search operator to use (see the list of supported operators below).
### Supported Operators
The following search operators are available:
| Operator | Description |
| -------- | ----------------------------------- |
| `eq` | Equal to |
| `gt` | Greater than |
| `lt` | Less than |
| `ne` | Not equal to |
| `lk` | Like (case-sensitive) |
| `il` | Insensitive like (case-insensitive) |
## How It Works
The search functionality works by evaluating each object in a JSON array against the specified query parameters. The `q` parameter defines the path to the field you want to search, the `value` parameter specifies the value to look for, and the `op` parameter indicates the comparison operator to use.
### Example 1: Basic Search
Suppose you have a private silo containing an array of objects like this:
```json data.json theme={null}
[
{ "id": 1, "name": "Alice", "age": 22 },
{ "id": 2, "name": "Bob", "age": 28 },
{ "id": 3, "name": "Charlie", "age": 31 }
]
```
Find objects where `age` is greater than `25`
* Use `?q=age` to specify the field to search.
* Use `&value=25` to set the value to compare against.
* Use `&op=gt` to set the operator to "greater than".
```bash theme={null}
?q=age&value=25&op=gt
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?q=age&value=25&op=gt
```
Response:
```json theme={null}
[
{ "id": 2, "name": "Bob", "age": 28 },
{ "id": 3, "name": "Charlie", "age": 31 }
]
```
### Example 2: Nested Field
Suppose your silo data looks like this:
```json data.json theme={null}
[
{ "id": 1, "profile": { "name": "Alice", "age": 22 } },
{ "id": 2, "profile": { "name": "Bob", "age": 28 } },
{ "id": 3, "profile": { "name": "Charlie", "age": 31 } }
]
```
Find objects where `profile.age` is less than `30`.
* Use `?q=profile.age` to specify the field to search.
* Use `&value=30` to set the value to compare against.
* Use `&op=lt` to set the operator to "less than".
```bash theme={null}
?q=profile.age&value=30&op=lt
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?q=profile.age&value=30&op=lt
```
Response:
```json theme={null}
[
{ "id": 1, "profile": { "name": "Alice", "age": 22 } }
]
```
### Example 3: Multiple Operators
> 🚧 Coming soon
## Combining parameter with `path`
You can combine the search parameters with the `path` parameter to extract specific fields from the matched objects.
### How It Works
When combining the `path` parameter with search parameters, the search is performed first to filter the objects based on the criteria defined by `q`, `value`, and `op`. After filtering, the `path` parameter is applied to extract the specified field from each of the matched objects.
Suppose your silo data looks like this:
```json data.json theme={null}
[
{ "id": 1, "profile": { "name": "Alice", "age": 22 } },
{ "id": 2, "profile": { "name": "Bob", "age": 28 } },
{ "id": 3, "profile": { "name": "Charlie", "age": 31 } }
]
```
If you want to find the `name` of users whose `profile.age` is greater than `25`, you would construct your request as follows:
* Use `?q=profile.age` to specify the field to search.
* Use `&value=25` to set the value to compare against.
* Use `&op=gt` to set the operator to "greater than".
* Use `&path=profile.name` to extract the `name` field from the matched objects.
```bash theme={null}
?q=profile.age&value=25&op=gt&path=profile.name
```
Example Request:
```bash theme={null}
GET https://[region-code].jsonsilo.com/[file-uuid]?q=profile.age&value=25&op=gt&path=profile.name
```
Response:
```json theme={null}
[
"Bob",
"Charlie"
]
```
> **Notes:**
>
> * The order of parameters is important. The search parameters (`q`, `value`, `op`) should come before the `path` parameter in the URL.
> * If no objects match the search criteria, the response will be an empty array.
> * The `path` parameter can extract nested fields as well.
> * When using the `path` parameter, ensure that the specified path exists in the matched objects to avoid `null` values in the response.
# Create Silo
Source: https://docs.jsonsilo.com/how-to/create-silo
Learn how to create a silo in JSONsilo to store and manage your JSON files effectively.
## Introduction
Creating a silo in JSONsilo allows you to securely store and manage your JSON files. This guide will walk you through the steps to create a new silo, and access it using the unique URL provided.
### Step 1: Navigate to Silos dashboard
Click on the "Silos" in the main navigation menu to access the Silos dashboard.
You will see a list of existing silos if you have any. To create a new silo, click on the "Create" or "Create new Silo" button or "Getting Started" if you have no silos yet.
### Step 2: Click on "Create Silo"
Click on the "Create Silo" button to start the silo creation process.
If you want to create a private silo that requires an [Access Key](/keys/access-keys) for access, select the "Private" option in the access field.
If you want to create a public silo that is accessible to anyone with the link, select the "Public" option in the access field.
### Step 3: Create/Upload your JSON file
Once you click on the "Next: Add JSON Data" button, you will be directed to the [JSON Editor](/editor/json-editor) page. You can either create a new JSON file from scratch using the built-in editor or upload an existing JSON file from your computer.
1. **Manual**: Use the JSON editor to create your JSON file by adding key-value pairs, arrays, and nested objects as needed.
2. **Upload**: Click on the "Upload" tab button to upload a JSON file from your computer. Make sure the file is in valid JSON format.
3. **Editor**: You can use the editor to create JSON data manually. You can also edit any JSON data that you upload if needed.
4. **Save**: After creating or uploading your JSON file, click the "Save" button to save and deploy your silo.
5. **Save & Close**: After creating or uploading your JSON file, click the "Save & Close" button to save and close the editor and you will be redirected to the silo details page.
That's it! You have successfully created a silo in JSONsilo. ✨
## What's next?
* Learn how to [view your silo details and access URL](how-to/view-silo).
* Learn how to [update your silo data](how-to/update-silo).
* Learn how to [delete your silo](how-to/delete-silo).
# Manage Silo
Source: https://docs.jsonsilo.com/how-to/manage-silo
Guide on how to manage a silo
## Introduction
Managing a silo in JSONsilo allows you to access and modify your stored JSON files. This guide will walk you through the steps to manage an existing silo and access its contents.
### Step 1: Navigate to Silos dashboard
Go to the "Silos" dashboard from the main menu. Select the silo you want to manage.
### Step 2: View Silo Details
Once you click on the silo you want to view, you will be taken to the silo details page. Here, you can see all the information related to the selected silo, including its JSON content, access settings, and more.
#### 1. Silo Details
1. **File Name**: The name of the silo.
2. **File UUID**: The unique identifier of the silo.
3. **Region / Code**: The region where the silo is hosted.
4. **Created At**: The date and time the silo was created.
5. **Last Modified**: The date and time the silo was last modified.
6. **Visibility / Access Type**: Indicates whether the silo is public or private.
7. **Link**: The URL to access the silo. For private silos, an Access Key is required.
8. **Edit**: Click this button to edit the silo's name.
#### 2. JSON Content
This section shows the JSON content stored in the silo. To view the full JSON structure, click the "Open JSON Editor" button.
For more details about the JSON Editor, check out our [JSON Editor Documentation](/editor/json-editor).
#### 3. Settings
This section allows you to manage silo access, region and delete the silo.
1. **Silo Access**: Click the "Manage" button to update the silo's access settings. You can switch between public and private access types and click "Save" to apply the changes.
2. **Region**: Click the "Manage" button to update the region where the silo is hosted and click "Save" to apply the changes.
3. **Delete Silo**: Click the "Delete" button to remove the silo permanently. A confirmation dialog will appear; type the silo name to confirm deletion and click "Delete" to proceed.
That's it! You have successfully managed your silo in JSONsilo. ✨
## What's next?
* Learn how to [use the JSON Editor to edit your JSON data.](/editor/json-editor)
* Learn how to [Search data in your silo](/search/silo-search).
* Learn how to [Query data in your silo](/query/silo-query).
# Introduction
Source: https://docs.jsonsilo.com/introduction
## What is JSONsilo.com?
JSONsilo is a simple tool for developers to host and share their `.json` files online without any hassle. It provides a quick and reliable way to make your JSON data accessible over the internet.
### Key Features:
* **Easy Hosting**: Upload your JSON files and get a shareable link instantly.
* **No Setup Required**: No need to configure servers or worry about hosting.
* **Secure and Reliable**: Your data is hosted securely and always available.
# Key concepts
Source: https://docs.jsonsilo.com/key-concepts
### What is a Silo?
A silo is a storage container for a JSON file. When you upload a JSON file to JSONsilo, it becomes a silo. Each silo has a unique file UUID that you can use to access the JSON file through our API.
### Public vs Private Silo
* **Public Silo**: These silos can be accessed by anyone with the URL. No authentication is required to read the JSON data stored in a public silo.
* **Private Silo**: These silos are restricted and require an **Access Key** for any operations. Only users with the correct Access Key can read the JSON data in a private silo.
### Access Keys vs Manage Keys
* **Access Keys**: These keys are used to authenticate API requests for private silos. They allow you to read the JSON data stored in the silo.
* **Manage Keys**: These keys provide higher-level access, allowing you to perform management operations such as creating, updating, or deleting silos.
### Region Codes
JSONsilo is hosted in multiple regions around the world. Each region has a unique code that is used in the API endpoints to specify where your silo is located.
| Region Code | Description |
| ------------ | ------------------ |
| `api` | General API region |
| `sg-01-api` | Singapore region |
| `usc-01-api` | US Central region |
### File UUID
Each silo is assigned a unique identifier (UUID) that is used to access it via the API. The UUID is **unchangeable** and consists of 32 hexadecimal characters separated by 4 hyphens, making it 36 characters long.
# Access Keys
Source: https://docs.jsonsilo.com/keys/access-keys
## What is an Access Key?
An Access Key is a unique identifier used to access private silos in JSONsilo. When you create a private silo, you need an Access Key to view or modify the data. This ensures that only authorized users can access the silo's contents.
## How to Generate an Access Key
To generate a new Access Key, follow these steps:
Click on the "Keys" menu in the sidebar and then click the `Manage` button.
Click the `Create new Access Key` button to generate a new Access Key.
In the dialog, enter a name for your Access Key and click the `Create Access Key` button.
Copy the Access Key and store it securely. You will need it to access your private silo.
Copy the key now, as you won't be able to see it again!
## Revoking an Access Key
To revoke an Access Key, follow these steps:
Click on the "Keys" menu in the sidebar and then click the `Manage` button.
Find the Access Key you want to revoke in the list and click the `Revoke` button next to it.
In the confirmation dialog, enter the key name and click the `Delete` button to revoke the Access Key.
## Best Practices for Managing Access Keys
* **Keep Your Access Keys Secret**: Treat your Access Keys like passwords. Do not share them publicly or expose them in client-side code.
* **Rotate Your Access Keys Regularly**: Periodically regenerate your Access Keys to minimize the risk of unauthorized access.
* **Use Environment Variables**: Store your Access Keys in environment variables instead of hardcoding them in your application.
# Manage Keys
Source: https://docs.jsonsilo.com/keys/manage-keys
## What is Manage Keys?
A Manage Key allows you to perform operations like creating, reading, updating, and deleting JSON files through API calls, without needing to sign in to the console.
For more information on using Manage Keys with the JSONsilo API, refer to our [API Reference Documentation](/api-reference/introduction).
## How to Create a Manage Key
Click on the "Keys" menu in the sidebar and then click the `Manage` button.
Click the `Create new Manage Key` button to generate a new Manage Key.
In the dialog, enter a name and select a duration for your Manage Key, then click the `Add key` button.
Copy the Manage Key and store it securely.
Copy the key now, as you won't be able to see it again!
## Revoking a Manage Key
To revoke a Manage Key, follow these steps:
Click on the "Keys" menu in the sidebar and then click the `Manage` button.
Find the Manage Key you want to revoke in the list and click the `Revoke` button next to it.
In the confirmation dialog, enter the key name and click the `Delete` button to revoke the Manage Key.
## Best Practices for Managing Manage Keys
* **Keep Your Manage Keys Secret**: Treat your Manage Keys like passwords. Do not share them publicly or expose them in client-side code.
* **Rotate Your Manage Keys Regularly**: Periodically regenerate your Manage Keys to minimize the risk of unauthorized access.
* **Use Environment Variables**: Store your Manage Keys in environment variables instead of hardcoding them in your application.
# Pricing Plans
Source: https://docs.jsonsilo.com/pricing-plans
Overview of JSONsilo pricing plans
Please visit our [Pricing Page](https://jsonsilo.com/#pricing) for the most up-to-date information on our pricing plans.
# Quick Start
Source: https://docs.jsonsilo.com/quick-start
Get started quickly with JSONsilo
Before you begin, ensure that you have a JSONsilo account. If you don't have one yet, [sign up here](https://console.jsonsilo.com/signup) and complete the onboarding process.
During the onboarding process, you will be prompted to create and deploy your first JSON file to JSONsilo. Follow the instructions provided in the onboarding wizard to deploy your JSON.
After completing the onboarding process and deploying your JSON file to JSONsilo, you will get a unique URL to access it. The URL format depends on whether your silo is private or public:
Replace `[region-code]` with the appropriate region code for your silo, and `[file-uuid]` with the unique identifier assigned to your JSON file.
#### Private Silo URL Format
```bash theme={null}
https://[region-code].jsonsilo.com/[file-uuid]
```
#### Public Silo URL Format
```bash theme={null}
https://[region-code].jsonsilo.com/public/[file-uuid]
```
### Supported Region Codes
| Region Code | Description |
| ------------ | ------------------ |
| `api` | General API region |
| `sg-01-api` | Singapore region |
| `usc-01-api` | US Central region |
For more details about supported regions, please refer to the [Regions Documentation](/how-to/manage/region).
#### Retrieving your file uuid and region code
To find your `file-uuid` and `region-code`, sign in to your JSONsilo console and navigate to the "Silos" and click one of your silos from the list.
Here, you will see the details of your silo, including the file UUID and the region where your silo is hosted.
### Retrieving your Access Key for Private Silo
To retrieve your Access Key for a private silo, go to the "Keys" menu in your JSONsilo console and click the `Manage` button.
Here, you can create a new Access key or view your existing keys. Click the `Create new Access Key` button to generate a new key if you don't have one yet.
A dialog will appear to prompt you to enter a key name for your Access Key. After entering the name, click the `Create access key` button to generate the key.
After creating the Access Key, make sure to copy and save it securely, as you will need it to access your private silo.
If you lose your Access Key, you can generate a new one by following the same steps. Make sure to revoke any old keys that you no longer use to keep your account secure.
### Accessing Your JSON File
Below are examples of how to access your JSON file using the generated URL.
**Accessing a Private Silo**
To access a private silo, include your Access Key in the request headers. Use the `X-SILO-KEY` header to provide your Access Key.
```bash Terminal theme={null}
curl -X GET \
-H 'X-SILO-KEY: ' \
-H 'Content-Type: application/json' \
https://[region-code].jsonsilo.com/[file-uuid]
```
**Accessing a Public Silo**
For public silos, you can access the JSON file directly without any authentication headers.
```bash Terminal theme={null}
curl -X GET \
-H 'Content-Type: application/json' \
https://[region-code].jsonsilo.com/public/[file-uuid]
```
**Accessing a Private Silo**
To access a private silo, include your Access Key in the request headers. Use the `X-SILO-KEY` header to provide your Access Key.
```javascript main.js theme={null}
fetch('https://[region-code].jsonsilo.com/[file-uuid]', {
method: 'GET',
headers: {
'X-SILO-KEY': '',
'Content-Type': 'application/json'
}
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```
**Accessing a Public Silo**
For public silos, you can access the JSON file directly without any authentication headers.
```javascript main.js theme={null}
fetch('https://[region-code].jsonsilo.com/public/[file-uuid]', {
method: 'GET',
headers: {
'Content-Type': 'application/json'
}
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```
**Accessing a Private Silo**
To access a private silo, include your Access Key in the request headers. Use the `X-SILO-KEY` header to provide your Access Key.
```python main.py theme={null}
import requests
url = 'https://[region-code].jsonsilo.com/[file-uuid]'
headers = {
'X-SILO-KEY': '',
'Content-Type': 'application/json'
}
response = requests.get(url, headers=headers)
if response.status_code == 200:
print(response.json())
else:
print('Error:', response.status_code)
```
**Accessing a Public Silo**
For public silos, you can access the JSON file directly without any authentication headers.
```python main.py theme={null}
import requests
url = 'https://[region-code].jsonsilo.com/public/[file-uuid]'
headers = {
'Content-Type': 'application/json'
}
response = requests.get(url, headers=headers)
if response.status_code == 200:
print(response.json())
else:
print('Error:', response.status_code)
```
# Regions
Source: https://docs.jsonsilo.com/regions
Guide on how to manage a silo region.
## Introduction
In this guide, we explain the concept of silo regions and region codes.
## Regions
JSONsilo is committed to delivering global availability, powering millions of requests daily to services and devices worldwide.
### Asia
| Region | Code | Status |
| --------- | ----------- | ----------- |
| Singapore | `sg-01-api` | Available |
| Japan | N/A | Coming Soon |
| India | N/A | Coming Soon |
| Malaysia | N/A | Coming Soon |
### Europe
| Region | Code | Status |
| ------------------- | ----- | --------- |
| Germany: Düsseldorf | `api` | Available |
### North America
| Region | Code | Status |
| ---------------------- | ------------ | ----------- |
| United States: Central | `usc-01-api` | Available |
| United States: West | N/A | Coming Soon |
## How to Change Silo Region
To change the region of your silo, follow these steps:
Ensure there are no active requests when changing the region. Otherwise, you may receive a `404` error.
After updating the region, use the correct base URL for the selected region.
Click the "Silos" menu in the sidebar to view your list of silos. Select the silo you want to update by clicking its name.
Scroll to the bottom of the silo details page, and in the *Settings* section, click the `Manage` button to update your silo region.
In the dialog, select the desired region from the list and click the `Save` button to save your changes.
Changing this will update your silo URL.
# Demo
Source: https://docs.jsonsilo.com/silo-types/demo
Examples of Public and Private Silos in JSONsilo
# Private Silo
Source: https://docs.jsonsilo.com/silo-types/private-silo
Introduction to Private Silos in JSONsilo
## What is a Private Silo?
A Private Silo in JSONsilo is a secure storage solution for your JSON files that restricts access to authorized users only. Unlike public silos, which can be accessed by anyone with the link, private silos require an Access Key for access, ensuring that your data remains confidential and protected.
## Key Features of Private Silos
* **Access Control**: Only users with the correct Access Key can access the data stored in a private silo.
* **Query and Search**: You can perform advanced queries and searches on the JSON data stored in your private silo.
## Use Cases
* **Confidential Data Storage**: Store sensitive JSON data that should not be publicly accessible.
* **Internal Applications**: Use private silos to manage JSON data for internal applications that require restricted access.
* **Development and Testing**: Create private silos for development and testing purposes, ensuring that test data remains secure.
## How to Create a Private Silo
To create a private silo, follow these steps:
1. Navigate to the Silos dashboard in JSONsilo console.
2. Click on the "Create new Silo" button.
3. Select the "Private" option in the access field.
4. Click "Next: Add JSON Data" button to proceed.
5. Upload or create your JSON file using the JSON Editor.
6. Save the silo to generate a unique URL.
## Accessing a Private Silo
To access a private silo, include your Access Key in the request headers. Use the `X-SILO-KEY` or `x-silo-key` header to provide your [Access Key](/keys/access-keys).
```bash Terminal theme={null}
curl -X GET \
-H 'X-SILO-KEY: ' \
-H 'Content-Type: application/json' \
https://[region-code].jsonsilo.com/[file-uuid]
```
```javascript main.js theme={null}
fetch('https://[region-code].jsonsilo.com/[file-uuid]', {
method: 'GET',
headers: {
'X-SILO-KEY': '',
'Content-Type': 'application/json'
}
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```
```python main.py theme={null}
import requests
url = 'https://[region-code].jsonsilo.com/[file-uuid]'
headers = {
'X-SILO-KEY': '',
'Content-Type': 'application/json'
}
response = requests.get(url, headers=headers)
if response.status_code == 200:
print(response.json())
else:
print('Error:', response.status_code)
```
## Rate Limits
Private silos have the same rate limits as public silos depending on your [subscription plan](/pricing-plans).
Here are some links you might find helpful:
* **Query Silo Data**: [Learn how to query private silos](/features/query-silo-data)
* **Search Silo Data**: [Learn how to search private silos](/features/search-silo-data)
# Public Silo
Source: https://docs.jsonsilo.com/silo-types/public-silo
Introduction to public silos in JSONsilo
## What is a Public Silo?
A Public Silo in JSONsilo is a storage solution for your JSON files that allows unrestricted access to anyone with the link. Public silos are ideal for sharing non-sensitive data with a wide audience, as they do not require any authentication or access keys.
## Key Features of Public Silos
* **Easy Sharing**: Share your JSON files with anyone by simply providing the link.
* **No Authentication Required**: Public silos do not require users to authenticate or provide access keys.
## Unsupported Features
* **Query and Search**: Advanced querying and searching capabilities are not available for public silos.
## Use Cases
* **Public APIs**: Use public silos to store JSON data for public APIs that do not require authentication.
* **Open Data**: Share open data sets with the community without any access restrictions.
* **Collaboration**: Facilitate collaboration by allowing team members to access shared JSON files without barriers.
* **Documentation**: Host JSON files for documentation purposes that need to be easily accessible to users.
## How to Create a Public Silo
To create a public silo, follow these steps:
1. Navigate to the Silos dashboard in JSONsilo console.
2. Click on the "Create new Silo" button.
3. Select the "Public" option in the access field.
4. Click "Next: Add JSON Data" button to proceed.
5. Upload or create your JSON file using the JSON Editor.
6. Save the silo to generate a unique URL.
## Accessing a Public Silo
For public silos, you can access the JSON file directly without any authentication headers.
```bash Terminal theme={null}
curl -X GET \
-H 'Content-Type: application/json' \
https://[region-code].jsonsilo.com/public/[file-uuid]
```
```javascript main.js theme={null}
fetch('https://[region-code].jsonsilo.com/public/[file-uuid]', {
method: 'GET',
headers: {
'Content-Type': 'application/json'
}
})
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error('Error:', error));
```
```python main.py theme={null}
import requests
url = 'https://[region-code].jsonsilo.com/public/[file-uuid]'
headers = {
'Content-Type': 'application/json'
}
response = requests.get(url, headers=headers)
if response.status_code == 200:
print(response.json())
else:
print('Error:', response.status_code)
```
## Rate Limits
Public silos have the same rate limits as private silos depending on your subscription plan.