How to Publish Your First NPM Package for AI Applications

Why Publish an NPM Package?

Publishing NPM packages has tangible benefits:

1. Community — Others use and improve your code
2. Reputation — A popular package is the best developer portfolio
3. Income — GitHub Sponsors, open-core monetization, consulting
4. Learning — The discipline of making something public forces quality

And in the AI space specifically, there's massive demand for well-built utility packages.

What Makes a Good AI NPM Package?

The best AI packages solve a specific, recurring problem:

• A unified API for multiple LLM providers
• A set of pre-built prompts for common tasks
• A connector for a specific data source (exchange, news API)
• A utility for parsing/validating LLM outputs

Bad idea: "A general AI library" (too broad, too much competition)
Good idea: "A TypeScript library for extracting structured data from crypto news articles" (specific, valuable)

Step 1: Plan Your Package

Before writing code, answer these questions:

• What problem does it solve?
• Who is the target user?
• What's the API surface (public functions/classes)?
• What's the package name? (Check npm.js first)

Step 2: Initialize Your Package

mkdir crypto-sentiment-ai && cd crypto-sentiment-ai
npm init -y
npm install typescript @types/node tsup --save-dev
npm install openai zod

Configure TypeScript:

// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "ESNext",
    "moduleResolution": "bundler",
    "strict": true,
    "declaration": true,
    "outDir": "dist",
    "rootDir": "src"
  },
  "include": ["src"]
}

Configure build with tsup (much easier than raw tsc):

// package.json
{
  "name": "crypto-sentiment-ai",
  "version": "0.1.0",
  "main": "dist/index.js",
  "module": "dist/index.mjs",
  "types": "dist/index.d.ts",
  "exports": {
    ".": {
      "import": "./dist/index.mjs",
      "require": "./dist/index.js",
      "types": "./dist/index.d.ts"
    }
  },
  "scripts": {
    "build": "tsup src/index.ts --format cjs,esm --dts",
    "test": "node --experimental-vm-modules node_modules/.bin/jest"
  }
}

Step 3: Write Your Core Code

// src/index.ts
import OpenAI from 'openai'
import { z } from 'zod'

const SentimentSchema = z.object({
  sentiment: z.enum(['bullish', 'bearish', 'neutral']),
  score: z.number().min(-1).max(1),
  confidence: z.number().min(0).max(1),
  reasoning: z.string(),
})

export type SentimentResult = z.infer<typeof SentimentSchema>

export interface SentimentAnalyzerOptions {
  apiKey?: string
  model?: string
}

export class CryptoSentimentAnalyzer {
  private client: OpenAI
  private model: string

  constructor(options: SentimentAnalyzerOptions = {}) {
    this.client = new OpenAI({ apiKey: options.apiKey || process.env.OPENAI_API_KEY })
    this.model = options.model || 'gpt-4o-mini'
  }

  async analyze(text: string, asset: string): Promise<SentimentResult> {
    const response = await this.client.chat.completions.create({
      model: this.model,
      messages: [{
        role: 'user',
        content: `Analyze sentiment about ${asset} in this text: "${text}"
        
Return JSON with: sentiment (bullish/bearish/neutral), score (-1 to 1), confidence (0 to 1), reasoning (string)`
      }],
      response_format: { type: 'json_object' }
    })

    const parsed = JSON.parse(response.choices[0].message.content!)
    return SentimentSchema.parse(parsed)
  }

  async analyzeBatch(texts: Array<{ text: string; asset: string }>): Promise<SentimentResult[]> {
    return Promise.all(texts.map(({ text, asset }) => this.analyze(text, asset)))
  }
}

// Named exports for tree-shaking
export { CryptoSentimentAnalyzer as default }

Step 4: Write Tests

// src/__tests__/index.test.ts
import { CryptoSentimentAnalyzer } from '../index'

describe('CryptoSentimentAnalyzer', () => {
  it('should return valid sentiment result', async () => {
    const analyzer = new CryptoSentimentAnalyzer()
    const result = await analyzer.analyze(
      'Bitcoin ETF sees massive inflows as institutions pile in',
      'Bitcoin'
    )
    
    expect(result.sentiment).toMatch(/bullish|bearish|neutral/)
    expect(result.score).toBeGreaterThanOrEqual(-1)
    expect(result.score).toBeLessThanOrEqual(1)
  })
})

Step 5: Write an Excellent README

This is the most important step. Your README is your package's landing page.

Structure:

1. One-line description — What it does
2. Install — npm install your-package
3. Quick start — Working code example in 5 lines
4. API reference — All public methods documented
5. Examples — Real use cases
6. Contributing — How to submit PRs
7. License — MIT is standard for open-source

Step 6: Publish to NPM

# 1. Create an NPM account at npmjs.com
# 2. Login via CLI
npm login

# 3. Build
npm run build

# 4. Dry run first (see what would be published)
npm publish --dry-run

# 5. Publish!
npm publish --access public

Step 7: Grow Your Package

After publishing:

• Share it — Post on Twitter/X, Reddit r/javascript, dev.to
• Add GitHub badges — npm version, downloads, license
• Respond to issues — Building trust and community
• Write examples — Each example is a potential SEO landing page
• Set up GitHub Sponsors — Let users support you financially

Monetization Strategies

• Open Core — Free base, paid premium features
• GitHub Sponsors — Community support
• Consulting — Package users become consulting clients
• Courses — "Build X with my package" courses

Popular crypto/AI NPM packages regularly receive $500–$5,000/month in sponsorships once they hit ~1,000 weekly downloads.

Get Inspired by Our Packages

Check the Tools page to see our published NPM packages — all open-source with full source code on GitHub.