[](https://badge.fury.io/js/api200-sdk-generator)

[](https://opensource.org/licenses/MIT)

A TypeScript SDK generator that automatically creates a fully-typed client library for your API200 services. Generate type-safe API clients with zero configuration and full IDE support.

-**Automatic Type Generation**: Creates TypeScript interfaces from your API schemas

-**Full Type Safety**: Compile-time error checking for API calls

-**Zero Configuration**: Works out of the box with sensible defaults

-**Path & Query Parameters**: Handles both path variables and query strings

-**Request Body Support**: Type-safe request body handling for POST/PUT/PATCH

-**Error Handling**: Structured error responses with status codes

-**IDE Support**: Full IntelliSense and autocomplete support

-**🔧 Zero Configuration** - Just provide your API token and go

-**📝 Full TypeScript Support** - Complete type safety with IntelliSense

-**🎯 Intuitive API** - Clean, predictable method naming

-**⚡ Fast Generation** - Generates SDK in seconds

-**🔄 Automatic Updates** - Re-run to sync with API changes

-**📦 No Dependencies** - Generated code has zero runtime dependencies

1.**Register with API200**: Sign up at[API200](https://api200.co) and set up your API proxy platform

2.**Import/Create Services**: Add your API services to the API200 platform

3.**Get API Token**: Obtain your user token from the API200 dashboard

npm install -g api200-sdk-generator

Generate your SDK using npx (no installation required):

npx api200-generate-sdk -tyour_api_token

npx api200-generate-sdk -tYOUR_API_TOKEN

npx api200-generate-sdk --token YOUR_API_TOKEN

| Option| Short| Description| Default|

|--------|-------|-------------|---------|

|`--token`|`-t`|**Required.** Your API200 user token||

|`--base-url`|`-u`| Base API URL|`https://eu.api200.co/api`|

|`--output`|`-o`| Output directory|`./src/lib/api200` or`./lib/api200`|

npx api200-generate-sdk -t YOUR_API_TOKEN -o ./src/api

api200-generate-sdk [options]

npx api200-generate-sdk -t your_token_here -o ./src/api

Options:

-t, --token<token> API200 user token (required)

-u, --base-url<url> Base API URL (default:"https://eu.api200.co/api")

-o, --output<path> Output directory (default:"./lib/api200")

-h, --help Displayhelpforcommand

npx api200-generate-sdk -t your_token_here -u https://us.api200.co/api

The generator createsa clean, organized SDK structure:

TheSDKgenerator createsthe following file structure:

import{api200 }from'./lib/api200';

importapi200from'./lib/api200';

const user=awaitapi200.users.getUserById.get({ id:"123" });

console.log(user.data);

const users=awaitapi200.users.getUsers.get({

page:1,

limit:10,

status:"active"

const { data, error }=awaitapi200.users.getUserById.get({

id:"123"

});

const newUser=awaitapi200.users.createUser.post({

requestBody: {

name:"John Doe",

email:"john@example.com"

}

});

import {api200 }from'./lib/api200';

importtype {ApiError }from'./lib/api200/types';

try {

const result=awaitapi200.users.getUserById.get({ id:"123" });

console.log('Success:',result.data);

}catch (error) {

const apiError=errorasApiError;

console.error('Error:',apiError.message);

console.error('Status:',apiError.status);

if (error) {

console.error('API Error:',error.message);

}else {

console.log('User data:',data);

}

import {api200 }from'./lib/api200';

importtype {GetUsersByIdParams,PostUsersParams }from'./lib/api200/types';

const params:GetUsersByIdParams= { id:"123" };

const user=awaitapi200.users.getUserById.get(params);

const createParams:PostUsersParams= {

requestBody: {

name:"John",

email:"john@example.com",

age:30// ✅ Correct type

}

};

When your API changes, simply re-run the generator to update your SDK:

Examples:

-`GET /users/{id}` →`getUserById.get()`

-`POST /users` →`createUser.post()`

-`PUT /users/{id}` →`updateUserById.put()`

-`DELETE /orders/{orderId}` →`deleteOrderByOrderId.delete()`

npx api200-generate-sdk -t YOUR_API_TOKEN

This will overwrite the existing SDK files with the latest API definitions.

The generator creates clean, predictable method names:

| API Endpoint| Generated Method|

|--------------|------------------|

You can also use environment variables instead of command-line options:

export API200_TOKEN=your_token_here

export API200_BASE_URL=https://eu.api200.co/api

export API200_OUTPUT=./lib/api200

npx api200-generate-sdk

All API methods return a consistent response structure:

Add generation to your package.json scripts:

interfaceAPI200Response<T> {

data:T|null;

error:API200Error|null;

}

{

"scripts": {

"generate-sdk":"api200-generate-sdk -t $API200_TOKEN",

"build":"npm run generate-sdk && tsc",

"dev":"npm run generate-sdk && npm run build -- --watch"

}

interfaceAPI200Error {

message:string;

status?:number;

details?:any;

}

**"Failed to fetch services" Error**

- Verify your API token is correct

- Check if the base URL is accessible

- Ensure you have internet connectivity

**TypeScript Compilation Errors**

- Make sure you have TypeScript installed:`npm install -D typescript`

- Check that your tsconfig.json includes the generated files

**Permission Errors**

- Ensure you have write permissions to the output directory

- Try running with elevated permissions if needed

- Check the[API 200](https://api200.co) documentation

- Open an issue on GitHub

- Contact support through the API 200 website

MIT License - see the[LICENSE](LICENSE) filefordetails.

The generator creates comprehensive TypeScript typesforall your APIs:

-**[API 200 Website](https://api200.co)** - Main service website

-**[API Documentation](https://api200.co/docs)** - Full API documentation

-**[GitHub Repository](https://github.com/your-org/api200-sdk-generator)** - Source code and issues

When you add new services or modify existing ones in API200:

1.**Regenerate the SDK**:

npx api200-generate-sdk -t YOUR_API_TOKEN

Contributions are welcome! Please feel free to submit a Pull Request.

2.**The generator will**:

- Fetch the latest service definitions

- Update all type definitions

- Add new service methods

- Preserve your existing configuration

1. Fork the repository

2. Create your feature branch (`git checkout -b feature/amazing-feature`)

3. Commit your changes (`git commit -m 'Add some amazing feature'`)

4. Push to the branch (`git push origin feature/amazing-feature`)

5. Open a Pull Request

3.**No breaking changes**: Existing code continues to work while new features become available