How to Use JQ to Rename a Key: A Quick Guide

In the modern digital landscape, data reigns supreme, and JSON (JavaScript Object Notation) has emerged as the lingua franca for data interchange, especially in the realm of web services and API communications. From configuring applications to transmitting information between servers and clients, JSON's lightweight, human-readable format makes it indispensable. However, the journey of data often involves transformations – sometimes minor, sometimes significant – to fit the specific requirements of consuming applications or internal systems. Among these transformations, renaming a key within a JSON structure is a remarkably common task, crucial for standardizing data, aligning with new schema definitions, or simply improving readability. This is where jq, the command-line JSON processor, becomes an invaluable tool in a developer's arsenal.

jq is often described as a "sed for JSON data," and for good reason. It allows you to slice, filter, map, and transform structured data with remarkable ease and power, all from the command line. While seemingly simple, renaming a key can sometimes involve navigating complex nested structures, applying conditional logic, or performing batch operations across arrays of objects. This comprehensive guide will delve deep into the mechanics of using jq to rename keys, exploring various scenarios from the straightforward to the intricate, equipping you with the knowledge to wield this powerful utility effectively in your daily development tasks. Whether you're a seasoned developer wrangling data from a complex api gateway or a newcomer looking to manipulate configuration files, understanding jq's capabilities for key renaming will significantly enhance your productivity and data manipulation prowess.

Unpacking the Power of jq: Why and How It Works

Before we dive into the specifics of renaming keys, it's essential to grasp the foundational concepts of jq. Imagine you're working with an api that returns a large JSON object, but the key names aren't quite what your application expects. Manually editing such data, especially if it's dynamic or voluminous, is not only tedious but also prone to errors. jq automates this process, providing a robust, declarative way to transform JSON.

What is jq and Why Do Developers Swear by It?

jq is a lightweight and flexible command-line JSON processor. It's essentially a functional programming language designed specifically for JSON data. With jq, you can: * Filter: Extract specific fields or elements. * Map: Transform values or structures. * Select: Choose data based on conditions. * Reduce: Aggregate data. * Format: Pretty-print JSON for readability.

Developers swear by jq because it bridges the gap between raw JSON data and the specific format required by applications or databases. It avoids the need for scripting languages (like Python or Node.js) for simple to moderately complex JSON transformations, making it incredibly fast and efficient for shell-based workflows. For example, when debugging api responses that come through a gateway, jq allows immediate inspection and transformation without leaving the terminal environment, saving considerable time and effort.

Installation and Basic Usage

Getting jq up and running is straightforward across most operating systems.

Installation: * macOS: brew install jq * Linux (Debian/Ubuntu): sudo apt-get install jq * Linux (CentOS/Fedora): sudo yum install jq * Windows: Download the executable from the official jq website or use scoop install jq (Scoop) / choco install jq (Chocolatey).

Basic Usage: The fundamental structure of a jq command is jq 'filter' [input_file]. If no input file is provided, jq reads from standard input.

Let's start with a simple JSON object:

{
  "user_name": "Alice",
  "email_address": "alice@example.com",
  "user_id": 123
}

To pretty-print this:

echo '{"user_name": "Alice", "email_address": "alice@example.com", "user_id": 123}' | jq '.'

Output:

{
  "user_name": "Alice",
  "email_address": "alice@example.com",
  "user_id": 123
}

The . filter simply outputs the entire input JSON. This is your starting point for any jq operation. Understanding this basic pipe mechanism is crucial, as you'll often combine jq with curl or other tools to process api responses on the fly.

The Art of Renaming Keys: Fundamental Approaches in jq

Renaming a key in jq isn't a single, monolithic command. Instead, it involves a combination of jq's powerful filters and functions to construct a new object with the desired key names. We'll explore several techniques, starting with the most common and moving towards more advanced patterns.

Approach 1: Deleting and Adding (The "Manual" Way)

One of the most intuitive ways to rename a key is to delete the old key and then add a new key with the desired name, transferring the value. While not always the most concise, this method clearly demonstrates the underlying operations.

Consider this input:

{
  "oldKey": "value",
  "anotherField": 123
}

To rename "oldKey" to "newKey":

1. Extract the value: We first need to get the value associated with oldKey.
2. Delete the old key: Use del(.oldKey).
3. Add the new key: Use + {newKey: .oldKey} after deleting, referencing the original value before deletion or using a temporary variable if needed. However, jq filters operate on a stream, and we need to be careful about state. A more robust way is to build a new object.

Let's combine these using jq's pipe (|) operator and object construction:

echo '{"oldKey": "value", "anotherField": 123}' | jq '{newKey: .oldKey} + del(.oldKey) + {anotherField}'

Wait, this is not quite right. del(.oldKey) operates on the entire object. A more direct construction creates a new object:

echo '{"oldKey": "value", "anotherField": 123}' | jq '{ "newKey": .oldKey, "anotherField": .anotherField }'

Output:

{
  "newKey": "value",
  "anotherField": 123
}

This approach explicitly constructs a new object, picking and choosing which fields to include and renaming oldKey to newKey in the process. While simple for small objects, it becomes cumbersome if you have many fields and only want to rename one, as you have to list all other fields explicitly.

Approach 2: Using with_entries for Dynamic and Concise Renaming

with_entries is a highly versatile and powerful jq function for transforming an object's keys and values. It converts an object into an array of key-value pairs, allows you to operate on this array, and then converts it back into an object. This is often the most elegant solution for renaming keys dynamically or conditionally.

The with_entries filter works as follows: 1. Takes an object as input. 2. Converts it into an array of objects, where each inner object has two fields: "key" and "value". For example, {"a": 1, "b": 2} becomes [{"key": "a", "value": 1}, {"key": "b", "value": 2}]. 3. Applies a filter (e.g., map) to each element of this array. 4. Converts the modified array back into an object.

Let's use with_entries to rename "oldKey" to "newKey":

echo '{"oldKey": "value", "anotherField": 123}' | jq 'with_entries(if .key == "oldKey" then .key = "newKey" else . end)'

Output:

{
  "newKey": "value",
  "anotherField": 123
}

Let's break down this powerful command: * with_entries(...): This is the main function that handles the conversion to and from key-value pairs. * if .key == "oldKey" then .key = "newKey" else . end: This is the filter applied to each key-value pair object (e.g., {"key": "oldKey", "value": "value"} or {"key": "anotherField", "value": 123}). * .key == "oldKey": Checks if the current key's name is "oldKey". * then .key = "newKey": If it is, the key field of the current object ({"key": ..., "value": ...}) is updated to "newKey". * else . end: If it's not "oldKey", the object remains unchanged (.).

This method is incredibly flexible because it allows you to apply any arbitrary logic within the if-then-else block, including regex matching for keys, conditional renaming based on values, or even renaming multiple keys simultaneously. This becomes particularly useful when processing data fetched from a poorly standardized api, where key names might vary slightly, requiring robust transformation rules.

Approach 3: Using map_values and to_entries (A Variation)

While with_entries is often the go-to, understanding to_entries and from_entries (its inverse) can provide deeper insight into jq's object manipulation capabilities. with_entries is essentially a shortcut for to_entries | map(filter) | from_entries.

Let's achieve the same rename using to_entries, map, and from_entries:

echo '{"oldKey": "value", "anotherField": 123}' | jq 'to_entries | map(if .key == "oldKey" then .key = "newKey" else . end) | from_entries'

The output is identical. This approach explicitly shows the three-step process with_entries encapsulates. For most key renaming tasks, with_entries is more concise, but explicitly using to_entries and from_entries can be clearer in more complex pipelines where intermediate transformations on the array of key-value pairs are significant.

APIPark is a high-performance AI gateway that allows you to securely access the most comprehensive LLM APIs globally on the APIPark platform, including OpenAI, Anthropic, Mistral, Llama2, Google Gemini, and more.Try APIPark now! 👇👇👇

Advanced Renaming Scenarios with jq

Beyond simple one-to-one key renames, jq excels at handling more complex scenarios that often arise when dealing with real-world data, especially from diverse api sources or configurations for different gateway environments.

Scenario 1: Renaming Multiple Keys Simultaneously

If you need to rename several keys within the same object, with_entries can be extended with multiple if-then-else conditions or a match statement.

Input:

{
  "first_name": "John",
  "last_name": "Doe",
  "email_addr": "john.doe@example.com",
  "user_id": 456
}

Goal: Rename first_name to firstName and email_addr to emailAddress.

echo '{ "first_name": "John", "last_name": "Doe", "email_addr": "john.doe@example.com", "user_id": 456 }' | jq '
  with_entries(
    if .key == "first_name" then .key = "firstName"
    elif .key == "email_addr" then .key = "emailAddress"
    else .
    end
  )
'

Output:

{
  "firstName": "John",
  "last_name": "Doe",
  "emailAddress": "john.doe@example.com",
  "user_id": 456
}

The elif (else if) construct allows you to chain multiple conditions elegantly, making this a powerful pattern for batch key renaming within a single object.

Scenario 2: Renaming Keys in Nested Objects

JSON structures often involve nesting, where objects contain other objects or arrays of objects. jq can traverse these structures to perform deep transformations.

Input:

{
  "user_profile": {
    "user_name": "Jane",
    "contact_info": {
      "email_addr": "jane@example.com",
      "phone_num": "123-456-7890"
    }
  },
  "status": "active"
}

Goal: Rename user_name to userName and email_addr to emailAddress.

For nested objects, you apply the renaming filter to the specific path where the key resides. The . operator is used for direct field access, and recursive descent (..) can also be useful for more global transformations.

To rename user_name within user_profile:

echo '...' | jq '.user_profile |= with_entries(if .key == "user_name" then .key = "userName" else . end)'

Here, |= is the "update assignment" operator. It takes the output of the right-hand side filter and assigns it back to the left-hand side path.

To rename email_addr within user_profile.contact_info:

echo '...' | jq '.user_profile.contact_info |= with_entries(if .key == "email_addr" then .key = "emailAddress" else . end)'

Combining these:

echo '{ "user_profile": { "user_name": "Jane", "contact_info": { "email_addr": "jane@example.com", "phone_num": "123-456-7890" } }, "status": "active" }' | jq '
  .user_profile |= (
    with_entries(if .key == "user_name" then .key = "userName" else . end) |
    .contact_info |= with_entries(if .key == "email_addr" then .key = "emailAddress" else . end)
  )
'

Output:

{
  "user_profile": {
    "userName": "Jane",
    "contact_info": {
      "emailAddress": "jane@example.com",
      "phone_num": "123-456-7890"
    }
  },
  "status": "active"
}

This demonstrates how jq allows you to target specific parts of your JSON structure for transformation, making it incredibly powerful for normalizing complex api responses.

Scenario 3: Renaming Keys in an Array of Objects

Often, you'll receive a JSON array where each element is an object, and you need to rename a key within each of these objects.

Input:

[
  {
    "item_id": "A1",
    "item_name": "Laptop",
    "price_usd": 1200
  },
  {
    "item_id": "B2",
    "item_name": "Mouse",
    "price_usd": 25
  },
  {
    "item_id": "C3",
    "item_name": "Keyboard",
    "price_usd": 75
  }
]

Goal: Rename item_id to productId and item_name to productName in every object in the array.

The map() function is perfect for this. map(filter) applies the filter to each element of an array.

echo '[ { "item_id": "A1", "item_name": "Laptop", "price_usd": 1200 }, { "item_id": "B2", "item_name": "Mouse", "price_usd": 25 }, { "item_id": "C3", "item_name": "Keyboard", "price_usd": 75 } ]' | jq '
  map(
    with_entries(
      if .key == "item_id" then .key = "productId"
      elif .key == "item_name" then .key = "productName"
      else .
      end
    )
  )
'

Output:

[
  {
    "productId": "A1",
    "productName": "Laptop",
    "price_usd": 1200
  },
  {
    "productId": "B2",
    "productName": "Mouse",
    "price_usd": 25
  },
  {
    "productId": "C3",
    "productName": "Keyboard",
    "price_usd": 75
  }
]

This combination of map and with_entries is incredibly powerful for normalizing lists of records, a very common task when consuming apis that return collections of resources.

Scenario 4: Conditional Renaming Based on Value

Sometimes, you might want to rename a key only if its value (or another key's value) meets certain criteria.

Input:

{
  "type": "user",
  "name_string": "Alice",
  "internal_id": "usr_001"
}

Goal: If type is "user", rename name_string to userName.

echo '{ "type": "user", "name_string": "Alice", "internal_id": "usr_001" }' | jq '
  if .type == "user" then
    with_entries(if .key == "name_string" then .key = "userName" else . end)
  else
    .
  end
'

Output:

{
  "type": "user",
  "userName": "Alice",
  "internal_id": "usr_001"
}

This pattern wraps the with_entries transformation within an if-then-else block, ensuring the key rename only occurs under specific conditions. This granular control is vital for robust data processing pipelines, especially when dealing with heterogeneous data streams that might come from various parts of an api ecosystem.

Scenario 5: Renaming Keys using Regular Expressions

For more complex key renaming patterns, jq supports regular expressions through its match function. This is particularly useful for transforming keys that follow a certain naming convention (e.g., converting snake_case to camelCase).

Input:

{
  "user_first_name": "Bob",
  "user_last_name": "Smith",
  "email_address": "bob.smith@example.com"
}

Goal: Rename user_first_name to userFirstName and user_last_name to userLastName (converting snake_case parts to camelCase, but only for keys starting with user_).

A full snake_case to camelCase conversion function is complex, but for specific patterns, we can use gsub. gsub(regex; string) replaces all occurrences of regex in a string with string.

Let's simplify: rename any key ending with _name to Name. This is illustrative, a full conversion is more involved.

echo '{ "user_first_name": "Bob", "user_last_name": "Smith", "email_address": "bob.smith@example.com" }' | jq '
  with_entries(
    .key |= gsub("_([a-zA-Z])"; (.[1] | ascii_upcase))
  )
'

Output:

{
  "userFirstName": "Bob",
  "userLastName": "Smith",
  "emailAddress": "bob.smith@example.com"
}

Let's break down gsub("_([a-zA-Z])"; (.[1] | ascii_upcase)): * .key |= ...: Updates the current key. * gsub("_([a-zA-Z])"; ...): Searches for an underscore followed by an alphabet character. The parentheses create a capture group for the alphabet character. * (.[1] | ascii_upcase): This is the replacement string. .[1] refers to the first captured group (the alphabet character after the underscore). ascii_upcase converts it to uppercase. This gsub essentially finds _f and replaces it with F, _l with L, and so on. This is a powerful technique for batch transforming naming conventions, a common requirement when integrating data from various legacy systems or third-party apis.

Real-World Applications and Best Practices

The ability to rename keys efficiently with jq transcends mere syntax and finds its true value in practical applications. Here are some common scenarios where this skill is invaluable, especially within the context of api and gateway management.

Processing API Responses

When you make a curl request to an api, the JSON response might not always align perfectly with the naming conventions or structure expected by your consuming application. jq can act as a crucial intermediary.

Example: Standardizing User Data from an API Suppose an api returns user data with id, name_first, and name_last. Your application expects userId, firstName, and lastName.

curl -s "https://api.example.com/users/123" | jq '
  {
    userId: .id,
    firstName: .name_first,
    lastName: .name_last,
    email: .email # Assuming email is already fine
  }
'

Or, for a more generic approach:

curl -s "https://api.example.com/users/123" | jq '
  with_entries(
    if .key == "id" then .key = "userId"
    elif .key == "name_first" then .key = "firstName"
    elif .key == "name_last" then .key = "lastName"
    else .
    end
  )
'

This demonstrates jq's role in the data transformation pipeline, ensuring that data retrieved from an api is immediately usable by downstream systems without requiring custom parsing logic in the application layer.

Normalizing Configuration Files

Configuration files (e.g., config.json) often need to be adapted for different environments or versions. Renaming keys can be part of this adaptation process. For instance, a legacy system might use database_host, while a newer system expects dbHost. jq facilitates this migration.

{
  "database_settings": {
    "database_host": "localhost",
    "database_port": 5432,
    "database_name": "my_app_db"
  },
  "api_keys": {
    "stripe_key": "sk_test_..."
  }
}

Goal: Rename database_host to dbHost, database_port to dbPort, database_name to dbName.

echo '...' | jq '
  .database_settings |= with_entries(
    if .key == "database_host" then .key = "dbHost"
    elif .key == "database_port" then .key = "dbPort"
    elif .key == "database_name" then .key = "dbName"
    else .
    end
  )
'

Working with API Gateways and Microservices

In a microservices architecture, an api gateway acts as a single entry point for clients, routing requests to various backend services. The data returned by these services might have inconsistent key naming. jq can be used on the client-side (or even within a custom gateway component if applicable) to unify these responses. For developers managing multiple apis and routing them through a central api gateway, tools like jq help ensure data consistency at various points in the system.

For instance, after a request passes through an api gateway, its response might combine data from several microservices, each with its own JSON schema. jq can then be used to post-process this aggregated response, renaming conflicting keys or standardizing them before sending the final data to the client. This client-side transformation offloads work from the gateway itself, keeping it focused on its core routing and security responsibilities.

APIPark and Streamlined API Management

While jq is a powerful client-side or command-line utility for individual data transformations, the broader context of managing the lifecycle and consistency of data flowing through APIs demands a more holistic approach. This is where platforms like APIPark come into play. APIPark, an open-source AI Gateway & API Management Platform, offers a comprehensive solution for managing, integrating, and deploying AI and REST services.

Consider a scenario where you're consuming data from various AI models integrated via APIPark. APIPark excels at providing a unified API format for AI invocation, meaning that even if the underlying AI models have different output structures, APIPark can standardize the response, significantly reducing the need for extensive jq transformations on the client-side. If, however, some custom post-processing or very specific key renaming is still required for an idiosyncratic application, jq can perfectly complement APIPark's capabilities by providing that final, granular layer of data massage. APIPark focuses on the management and standardization upstream, making the downstream job for tools like jq much simpler by reducing the initial data heterogeneity. It streamlines the API ecosystem, ensuring consistency and ease of use for developers who might then use jq for the final mile of data preparation.

APIPark’s features, such as quick integration of over 100 AI models and prompt encapsulation into REST API, mean that the api responses themselves are often well-structured. However, in complex enterprise environments or when integrating with specific legacy systems, the need for dynamic key renaming with tools like jq can still arise to perfectly match bespoke application requirements. APIPark helps manage the entire API lifecycle, from design to publication and invocation, providing detailed API call logging and powerful data analysis, which are critical for understanding the data flows that jq might then manipulate.

Best Practices for Using jq to Rename Keys

1. Start Small, Test Iteratively: When building complex jq filters, especially for nested structures or arrays, start with a minimal filter and gradually add complexity. Test each step to ensure it behaves as expected.
2. Use .|= for In-Place Updates: The update assignment operator (|=) is excellent for modifying specific parts of an object without reconstructing the entire object, leading to more readable and often more efficient filters for nested structures.
3. Leverage with_entries for Object-Wide Transformations: For most key renaming tasks within a single object, with_entries is your most versatile and readable option.
4. Combine map and with_entries for Arrays of Objects: This pattern is crucial for transforming collections of records consistently.
5. Use if-then-else for Conditional Logic: Don't rename blindly. Use conditions to ensure keys are only renamed when appropriate.
6. Escape Special Characters: If your keys contain special characters that jq interprets (e.g., ., -), remember to quote them or use ."key-name".
7. Consider Readability: For very complex transformations, consider breaking your jq filter into multiple lines within a shell script or using variables (def) for better readability.

Common jq Renaming Challenges and Solutions

Challenge	Description	jq Solution	Example Filter
Simple Rename	Change one specific key to another name.	Use with_entries with a direct key comparison.	with_entries(if .key == "oldName" then .key = "newName" else . end)
Nested Rename	Rename a key that is inside a nested object.	Target the nested object path with |=, then apply with_entries.	.outer.inner |= with_entries(if .key == "oldNestedKey" then .key = "newNestedKey" else . end)
Array of Objects Rename	Rename a key within each object in an array.	Use map() to iterate over the array, applying with_entries to each object.	map(with_entries(if .key == "oldKeyInArray" then .key = "newKeyInArray" else . end))
Conditional Rename	Rename a key only if a certain condition (e.g., another field's value) is met.	Wrap the with_entries logic in an if-then-else statement.	if .status == "active" then with_entries(if .key == "id" then .key = "activeId" else . end) else . end
Bulk Rename (Pattern)	Rename multiple keys based on a pattern (e.g., _ to _).	Use with_entries and gsub for regular expression-based replacements on .key.	with_entries(.key |= gsub("_([a-z])"; (.[1] | ascii_upcase))) (snake_case to camelCase for specific pattern)
Keeping Order	Ensure the order of keys is preserved after renaming.	jq generally preserves key order for operations like with_entries if no re-composition or sorting is explicitly done.	(Default behavior with with_entries often maintains order unless explicitly disturbed by other filters)
Renaming Dynamic Keys	Renaming keys whose names are not known beforehand but follow a pattern.	Use with_entries and pattern matching on .key (e.g., startswith, endswith, test with regex).	with_entries(if .key | startswith("temp_") then .key = (.key | lstripstr("temp_") | "final_" + .) else . end)
Deleting Old Key Only	Sometimes, you want to delete an old key and insert a new one, but not necessarily copy the value.	Use del(.oldKey) to remove, then |= . + {newKey: "someValue"} to add. (Not typical for 'renaming' but useful in similar contexts).	del(.oldKey) + {newKey: "default_value"} (This is more adding a new key after deleting an unrelated old one, rather than a rename)

This table serves as a quick reference for common renaming challenges and how jq can tackle them effectively, ensuring your data transformations are precise and adaptable.

Conclusion: Mastering JSON Transformation with jq

In an ecosystem increasingly driven by data and interconnected via APIs and gateways, the ability to efficiently manipulate JSON data is no longer a niche skill but a fundamental requirement for developers, data engineers, and operations professionals alike. jq stands out as an indispensable command-line tool, offering unparalleled power and flexibility for transforming JSON structures.

This guide has taken you through the core concepts of jq and, more specifically, the art of renaming keys. From simple, direct replacements to complex conditional and nested transformations, jq provides a rich set of filters and functions to handle virtually any key renaming scenario you might encounter. We've explored with_entries as the cornerstone for robust key transformations, delved into map for handling arrays of objects, and even touched upon regular expressions for pattern-based renames.

Whether you're streamlining api responses for a client application, standardizing configuration files across environments, or preparing data for analysis, mastering jq for key renaming will significantly enhance your workflow. It empowers you to perform rapid, precise, and automatable data transformations directly from your terminal, reducing reliance on heavier scripting languages for common tasks.

As data flows become more complex and disparate, tools like jq ensure that you maintain control over your JSON data, shaping it to precisely fit your needs. And while jq handles the granular transformations, remember that comprehensive platforms like APIPark provide the overarching framework for managing, standardizing, and securing your entire api ecosystem, laying a solid foundation for the clean, consistent data that jq then helps to refine even further. Embrace jq, and unlock a new level of command-line data mastery.

---

Frequently Asked Questions (FAQs)

1. What is jq and why is it useful for renaming keys?

jq is a lightweight, command-line JSON processor. It allows you to slice, filter, map, and transform structured JSON data with ease. It's particularly useful for renaming keys because it provides powerful filters like with_entries that can dynamically change key names based on conditions, patterns, or specific values, all without needing to write full scripts in other programming languages. This makes it highly efficient for quick, automatable JSON manipulations.

2. What's the most common jq filter used for renaming keys?

The with_entries filter is generally the most common and versatile for renaming keys. It converts an object into an array of {"key": ..., "value": ...} pairs, allowing you to modify the .key field for specific entries, and then converts it back into an object. This approach offers great flexibility for conditional and dynamic renaming.

3. Can I rename keys in nested JSON objects or arrays of objects using jq?

Yes, jq excels at handling nested structures. For nested objects, you can target the specific path (e.g., .outer.inner |= ...) and then apply a renaming filter like with_entries. For arrays of objects, you typically use the map() function to iterate over each object in the array, applying your key renaming logic (often using with_entries) to each element.

4. How can jq help with data from an API or API Gateway?

When consuming data from an API or an API Gateway, the JSON responses might not always match your application's expected data schema or naming conventions. jq can be used as a post-processing tool (e.g., piped after a curl command) to transform these responses on the fly. You can rename keys, reorder fields, or restructure the entire JSON to align with your internal data models, making the API data immediately usable.

5. Does jq permanently modify my original JSON file?

No, jq is a stream editor. By default, it reads JSON from standard input or a specified file and prints the transformed JSON to standard output. It does not modify the original input file. If you want to save the changes, you need to redirect the output of jq to a new file or use an in-place editing utility like sponge (from moreutils) if you want to overwrite the original file (e.g., jq '...' input.json | sponge input.json). Always exercise caution when overwriting files.

🚀You can securely and efficiently call the OpenAI API on APIPark in just two steps:

Step 1: Deploy the APIPark AI gateway in 5 minutes.

APIPark is developed based on Golang, offering strong product performance and low development and maintenance costs. You can deploy APIPark with a single command line.

curl -sSO https://download.apipark.com/install/quick-start.sh; bash quick-start.sh

In my experience, you can see the successful deployment interface within 5 to 10 minutes. Then, you can log in to APIPark using your account.

Step 2: Call the OpenAI API.