@adityanair98/api-oracle 0.5.0

package/src/entries/search/algolia.json

@@ -0,0 +1,96 @@
+{
+  "name": "Algolia",
+  "slug": "algolia",
+  "category": "search",
+  "subcategory": "hosted-search",
+  "website": "https://www.algolia.com",
+  "description": "Algolia is a hosted search API that delivers sub-100ms search results with typo tolerance, faceting, and relevance tuning. It is the standard for adding fast, user-facing search to e-commerce, documentation sites, and SaaS applications — without the complexity of running Elasticsearch.",
+  "useCases": [
+    {
+      "task": "Add real-time search with typo tolerance to a web application",
+      "fit": "perfect"
+    },
+    {
+      "task": "Build e-commerce product search with filtering and facets",
+      "fit": "perfect"
+    },
+    {
+      "task": "Add instant search to a documentation site",
+      "fit": "perfect"
+    },
+    {
+      "task": "Build search autocomplete and suggestions",
+      "fit": "perfect"
+    },
+    {
+      "task": "Full-text search on unstructured text without indexing",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at algolia.com",
+      "Create a new Application",
+      "Go to Settings > API Keys",
+      "Copy the Application ID, Search-Only API Key (for frontend), and Admin API Key (for indexing)",
+      "Set ALGOLIA_APP_ID, ALGOLIA_SEARCH_API_KEY, and ALGOLIA_ADMIN_API_KEY environment variables",
+      "Never expose the Admin API Key on the frontend — use the Search-Only key in client code"
+    ],
+    "envVarName": "ALGOLIA_ADMIN_API_KEY",
+    "codeSnippet": "import algoliasearch from 'algoliasearch';\nconst client = algoliasearch(process.env.ALGOLIA_APP_ID!, process.env.ALGOLIA_ADMIN_API_KEY!);\nconst index = client.initIndex('products');"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "10,000 records, 10,000 search requests/month",
+    "startingPrice": "$50/month (Grow plan) for higher limits",
+    "costPer": "Varies by plan; roughly $1/1,000 search operations beyond plan limits",
+    "pricingUrl": "https://www.algolia.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "10,000 search operations/month, 10,000 records, 10 indices",
+    "notes": "An 'operation' is counted per index searched. If you search 3 indices per query, that's 3 operations per search. Rate limits on API calls are generous (unlimited on paid plans).",
+    "retryStrategy": "Algolia's client SDK handles retries and failover automatically. The SDK retries against multiple hosts for reliability."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact algoliasearch",
+    "importStatement": "import algoliasearch from 'algoliasearch';",
+    "otherLanguages": ["python", "ruby", "java", "php", "go", "swift", "kotlin", "scala"]
+  },
+  "codeExamples": [
+    {
+      "title": "Index records and search",
+      "language": "typescript",
+      "code": "import algoliasearch from 'algoliasearch';\n\n// Admin client for indexing (server-side only)\nconst client = algoliasearch(\n  process.env.ALGOLIA_APP_ID!,\n  process.env.ALGOLIA_ADMIN_API_KEY!\n);\nconst index = client.initIndex('products');\n\n// Index some records\nawait index.saveObjects([\n  { objectID: '1', name: 'iPhone 15 Pro', brand: 'Apple', price: 999 },\n  { objectID: '2', name: 'Galaxy S24', brand: 'Samsung', price: 899 },\n]);\n\n// Search\nconst { hits } = await index.search('iphone', {\n  hitsPerPage: 10,\n  filters: 'price < 1000',\n});\n\nconsole.log('Results:', hits.map(h => h.name));",
+      "notes": "Always provide objectID for each record. Without it, Algolia generates one, making updates and deletes harder. Use saveObject() for upserts."
+    },
+    {
+      "title": "React InstantSearch (frontend)",
+      "language": "typescript",
+      "code": "import { liteClient } from 'algoliasearch/lite';\nimport { InstantSearch, SearchBox, Hits } from 'react-instantsearch';\n\nconst searchClient = liteClient(\n  process.env.NEXT_PUBLIC_ALGOLIA_APP_ID!,\n  process.env.NEXT_PUBLIC_ALGOLIA_SEARCH_KEY! // Search-only key\n);\n\nfunction ProductHit({ hit }: { hit: Record<string, unknown> }) {\n  return <div>{String(hit.name)} — ${String(hit.price)}</div>;\n}\n\nexport function ProductSearch() {\n  return (\n    <InstantSearch searchClient={searchClient} indexName=\"products\">\n      <SearchBox placeholder=\"Search products...\" />\n      <Hits hitComponent={ProductHit} />\n    </InstantSearch>\n  );\n}",
+      "notes": "Use algoliasearch/lite on the frontend for a smaller bundle. Use your Search-Only API key in NEXT_PUBLIC_ env vars — never the Admin key."
+    }
+  ],
+  "gotchas": [
+    "The Admin API key has full write access including deleting your entire index. Never expose it in client-side code. Use the Search-Only API key for all frontend/client usage.",
+    "Algolia counts 'operations' not requests. A single search that touches multiple indices counts as multiple operations. With 10,000 operations/month on the free tier, this is easy to exhaust with moderate traffic.",
+    "Records must be JSON objects with a maximum size of 10KB. Large text content must be chunked before indexing. Images and binary files cannot be stored — only their metadata.",
+    "Index settings (searchable attributes, ranking, facets) must be configured explicitly. The defaults are reasonable but production search quality requires tuning ranking formulas and facet configuration.",
+    "Algolia is not free for any meaningful production traffic. The 10k operation free tier is exhausted quickly. Budget for at least $50/month if you have real users."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.99% SLA on paid plans; distributed across 3 data centers per cluster",
+    "statusPageUrl": "https://status.algolia.com",
+    "notes": "Algolia's search infrastructure is globally distributed with automatic failover. Average response time is under 10ms."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "The gold standard for hosted search — unmatched search quality, excellent TypeScript SDK, and great documentation. The pricing model (per operation, not per query) is confusing and expensive at scale. For simple use cases, the free tier is exhausted quickly. Excellent product, challenging economics.",
+  "alternatives": [],
+  "complementary": ["stripe", "cloudinary"],
+  "bestFor": "Real-time site search with typo tolerance, facets, and sub-100ms responses for e-commerce and documentation sites",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-1"
+}

package/src/entries/security/arcjet.json

@@ -0,0 +1,89 @@
+{
+  "name": "Arcjet",
+  "slug": "arcjet",
+  "category": "security",
+  "subcategory": "app-security",
+  "website": "https://arcjet.com",
+  "description": "Arcjet is a developer-first security SDK for Node.js, Next.js, Bun, and Deno applications. Provides rate limiting, bot protection, email validation, attack protection (SQL injection, XSS), and shield middleware — all via a single SDK installed in your app. Unlike WAFs that sit in front of your server, Arcjet runs as middleware inside your application code.",
+  "useCases": [
+    {
+      "task": "Add rate limiting to an API endpoint without external infrastructure",
+      "fit": "perfect"
+    },
+    {
+      "task": "Protect a signup form from bot signups with email validation",
+      "fit": "perfect"
+    },
+    {
+      "task": "Block common attack patterns (SQLi, XSS) at the application layer",
+      "fit": "good"
+    },
+    {
+      "task": "Implement tiered rate limiting (free users vs paid users)",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create an Arcjet account at arcjet.com",
+      "Create a new site in the Arcjet dashboard",
+      "Copy the ARCJET_KEY from the site settings",
+      "Install the SDK: npm install @arcjet/next (or @arcjet/node for plain Node.js)",
+      "Add ARCJET_KEY to your .env file and middleware configuration"
+    ],
+    "envVarName": "ARCJET_KEY",
+    "codeSnippet": "// ARCJET_KEY=ajkey_your_key_here\n\nimport arcjet, { shield } from '@arcjet/next';\n\nconst aj = arcjet({\n  key: process.env.ARCJET_KEY!,\n  rules: [\n    // Shield detects common attacks: SQLi, XSS, path traversal\n    shield({ mode: 'LIVE' }),\n  ],\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: 10,000 requests/month, all features included",
+    "startingPrice": "$29/month (Starter) for 500,000 requests/month",
+    "costPer": "$5/million requests above included",
+    "pricingUrl": "https://arcjet.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "10,000 total requests/month (not just rate-limited requests — all traffic through Arcjet middleware counts). Each request that passes through the Arcjet SDK counts.",
+    "notes": "All requests routed through Arcjet middleware count toward the monthly limit, not just blocked ones. For high-traffic routes (e.g., public homepage), exempt them from Arcjet to conserve quota.",
+    "retryStrategy": "Arcjet returns ArcjetDecision objects with DENY/ALLOW/CHALLENGE decisions. Implement graceful degradation: if Arcjet SDK returns an error, fail open (allow the request) to avoid downtime."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @arcjet/next",
+    "importStatement": "import arcjet, { tokenBucket, shield, detectBot, validateEmail } from '@arcjet/next';",
+    "otherLanguages": ["javascript", "bun", "deno"]
+  },
+  "codeExamples": [
+    {
+      "title": "Rate limit an API route with Arcjet (Next.js)",
+      "language": "typescript",
+      "code": "import arcjet, { tokenBucket, shield } from '@arcjet/next';\nimport { NextRequest, NextResponse } from 'next/server';\n\nconst aj = arcjet({\n  key: process.env.ARCJET_KEY!,\n  characteristics: ['ip.src'],\n  rules: [\n    // Protect against common web attacks\n    shield({ mode: 'LIVE' }),\n    // Token bucket: 10 requests capacity, refills 10 per 60 seconds\n    tokenBucket({\n      mode: 'LIVE',\n      refillRate: 10,\n      interval: 60,\n      capacity: 10,\n    }),\n  ],\n});\n\nexport async function POST(req: NextRequest): Promise<NextResponse> {\n  const decision = await aj.protect(req, { requested: 1 });\n\n  if (decision.isDenied()) {\n    if (decision.reason.isRateLimit()) {\n      return NextResponse.json(\n        { error: 'Too many requests. Please try again later.' },\n        { status: 429 }\n      );\n    }\n    if (decision.reason.isShield()) {\n      return NextResponse.json(\n        { error: 'Suspicious request blocked.' },\n        { status: 403 }\n      );\n    }\n    return NextResponse.json({ error: 'Forbidden.' }, { status: 403 });\n  }\n\n  // Request is allowed — proceed with handler logic\n  const body: unknown = await req.json();\n  return NextResponse.json({ ok: true, received: body });\n}",
+      "notes": "The requested: 1 argument deducts 1 token per request. For expensive operations (e.g., AI inference), pass requested: 5 to deduct more tokens and enforce stricter limits without changing the rate limit config."
+    },
+    {
+      "title": "Bot protection and email validation on signup",
+      "language": "typescript",
+      "code": "import arcjet, { detectBot, validateEmail, shield } from '@arcjet/next';\nimport { NextRequest, NextResponse } from 'next/server';\n\nconst aj = arcjet({\n  key: process.env.ARCJET_KEY!,\n  characteristics: ['ip.src'],\n  rules: [\n    shield({ mode: 'LIVE' }),\n    // Block bots — allow search engine crawlers\n    detectBot({\n      mode: 'LIVE',\n      allow: ['CATEGORY:SEARCH_ENGINE', 'CATEGORY:MONITOR'],\n    }),\n    // Reject disposable/invalid email addresses\n    validateEmail({\n      mode: 'LIVE',\n      block: ['DISPOSABLE', 'INVALID', 'NO_MX_RECORDS'],\n    }),\n  ],\n});\n\ninterface SignupBody {\n  email: string;\n  name: string;\n}\n\nexport async function POST(req: NextRequest): Promise<NextResponse> {\n  const body = (await req.json()) as SignupBody;\n\n  const decision = await aj.protect(req, { email: body.email });\n\n  if (decision.isDenied()) {\n    if (decision.reason.isEmail()) {\n      return NextResponse.json(\n        { error: 'Invalid or disposable email address. Please use a real email.' },\n        { status: 422 }\n      );\n    }\n    if (decision.reason.isBot()) {\n      return NextResponse.json(\n        { error: 'Automated signups are not allowed.' },\n        { status: 403 }\n      );\n    }\n    return NextResponse.json({ error: 'Signup blocked.' }, { status: 403 });\n  }\n\n  // Valid human with a real email — create the account\n  return NextResponse.json({ ok: true, message: 'Account created.' });\n}",
+      "notes": "Pass email: body.email to aj.protect() so Arcjet's validateEmail rule can check the specific address in the request. The DISPOSABLE block type rejects known temporary email providers (Mailinator, 10minutemail, etc.) without your own blocklist."
+    }
+  ],
+  "gotchas": [
+    "Arcjet counts ALL requests through its middleware toward your monthly limit — not just blocked or rate-limited ones. On a public site with 100K pageviews/month, that's 100K Arcjet requests. Either exempt public-facing routes from Arcjet middleware or upgrade to a paid plan early.",
+    "Arcjet adds latency to every request it processes (typically 1-5ms for cloud analysis). For APIs with strict latency requirements (under 10ms P99), this overhead may be significant. Profile with and without Arcjet before deploying to latency-sensitive endpoints.",
+    "Arcjet's bot detection can block legitimate crawlers (Googlebot, Bingbot) if the rule is too aggressive. Use the category-specific allow list (detectBot({ allow: ['CATEGORY:SEARCH_ENGINE'] })) to whitelist known good bots."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.99% uptime SLA",
+    "statusPageUrl": "https://status.arcjet.com",
+    "notes": "Globally distributed edge network. Arcjet SDK includes a local fallback mode: if the Arcjet cloud is unreachable, the SDK fails open (allows requests) to prevent your app from going down due to a security service outage."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Best developer experience for adding rate limiting and bot protection as code — no separate WAF configuration, no infrastructure changes, just npm install and middleware. The SDK approach means security rules are version-controlled alongside the app. Main limitation: request-based billing (not just blocked requests) can be expensive on high-traffic public routes.",
+  "alternatives": [],
+  "complementary": ["vercel", "cloudflare-workers", "supabase", "clerk"],
+  "bestFor": "Adding rate limiting, bot protection, and attack detection directly in your Node.js or Next.js application code — no WAF or reverse proxy required",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/security/snyk.json

@@ -0,0 +1,90 @@
+{
+  "name": "Snyk",
+  "slug": "snyk",
+  "category": "security",
+  "subcategory": "vulnerability-scanning",
+  "website": "https://snyk.io",
+  "description": "Snyk is a developer security platform that scans code, open source dependencies, container images, and infrastructure-as-code for vulnerabilities. Integrates with GitHub, GitLab, CI/CD pipelines, and IDEs. The Snyk API allows automating vulnerability scans and reporting programmatically. Used by security-conscious teams to catch vulnerabilities before they reach production.",
+  "useCases": [
+    {
+      "task": "Scan npm dependencies for known vulnerabilities in CI/CD",
+      "fit": "perfect"
+    },
+    {
+      "task": "Get automated pull request checks for new dependency vulnerabilities",
+      "fit": "perfect"
+    },
+    {
+      "task": "Audit a project's dependencies for security issues",
+      "fit": "good"
+    },
+    {
+      "task": "Monitor a production deployment for newly discovered vulnerabilities",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create a Snyk account at snyk.io",
+      "Navigate to Account Settings (top-right avatar menu)",
+      "Scroll to Auth Token and click to reveal your token",
+      "Copy the token",
+      "Install the CLI globally: npm install -g snyk",
+      "Authenticate the CLI: snyk auth (opens browser) or set SNYK_TOKEN env var directly"
+    ],
+    "envVarName": "SNYK_TOKEN",
+    "codeSnippet": "// SNYK_TOKEN=your_snyk_token\n\n// Test dependencies for vulnerabilities (CLI)\n// SNYK_TOKEN=$SNYK_TOKEN snyk test --json\n\n// In CI, fail the build on high-severity issues\n// snyk test --severity-threshold=high\n\n// Monitor a project (uploads snapshot for ongoing monitoring)\n// snyk monitor --project-name=my-app"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "Free: 200 open source tests/month, unlimited projects, IDE integration, 1 contributor",
+    "startingPrice": "$25/contributor/month (Team) for unlimited tests, PR checks, license compliance",
+    "costPer": null,
+    "pricingUrl": "https://snyk.io/plans/"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "200 open source test runs/month (free). API: rate limits not publicly documented but throttling occurs for bulk operations.",
+    "notes": "CLI test runs against the Snyk API count toward monthly test limits. CI/CD integration should be configured to test only on meaningful events (push to main, PR creation) rather than every commit to conserve test quota.",
+    "retryStrategy": "Use --json flag with snyk test for structured output. Implement retry for API timeout errors in CI scripts."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact snyk",
+    "importStatement": "// Primary interface is CLI: snyk test, snyk monitor. REST API available for reporting.",
+    "otherLanguages": ["python", "java", "go", "ruby"]
+  },
+  "codeExamples": [
+    {
+      "title": "Add Snyk to a CI/CD pipeline (GitHub Actions)",
+      "language": "typescript",
+      "code": "// .github/workflows/security.yml\n// name: Security scan\n// on:\n//   push:\n//     branches: [main]\n//   pull_request:\n//     branches: [main]\n// jobs:\n//   snyk:\n//     runs-on: ubuntu-latest\n//     steps:\n//       - uses: actions/checkout@v4\n//       - uses: actions/setup-node@v4\n//         with:\n//           node-version: '20'\n//       - run: npm ci\n//       - uses: snyk/actions/node@master\n//         env:\n//           SNYK_TOKEN: ${{ secrets.SNYK_TOKEN }}\n//         with:\n//           args: --severity-threshold=high --json-file-output=snyk-results.json\n//       - uses: actions/upload-artifact@v4\n//         if: always()\n//         with:\n//           name: snyk-results\n//           path: snyk-results.json\n\n// Parse Snyk JSON output in TypeScript\nimport { execSync } from 'child_process';\n\ninterface SnykVulnerability {\n  id: string;\n  title: string;\n  severity: 'critical' | 'high' | 'medium' | 'low';\n  packageName: string;\n  version: string;\n  fixedIn: string[];\n}\n\ninterface SnykResult {\n  ok: boolean;\n  vulnerabilities: SnykVulnerability[];\n  dependencyCount: number;\n}\n\nfunction runSnykTest(projectPath: string): SnykResult {\n  const output = execSync(`snyk test --json`, {\n    cwd: projectPath,\n    env: { ...process.env, SNYK_TOKEN: process.env.SNYK_TOKEN },\n  }).toString();\n  return JSON.parse(output) as SnykResult;\n}",
+      "notes": "Use snyk/actions/node@master in GitHub Actions for the simplest integration. The --json-file-output flag writes results even when vulnerabilities are found (snyk test exits with code 1 on findings, which would otherwise fail the step before output is written)."
+    },
+    {
+      "title": "Run Snyk vulnerability test programmatically",
+      "language": "typescript",
+      "code": "import { execSync, ExecSyncOptionsWithStringEncoding } from 'child_process';\n\ninterface SnykVuln {\n  id: string;\n  title: string;\n  severity: string;\n  packageName: string;\n  version: string;\n  fixedIn: string[];\n  isUpgradable: boolean;\n  isPatchable: boolean;\n}\n\ninterface SnykReport {\n  ok: boolean;\n  vulnerabilities: SnykVuln[];\n  dependencyCount: number;\n  summary: string;\n}\n\nfunction auditDependencies(cwd: string): SnykReport {\n  const opts: ExecSyncOptionsWithStringEncoding = {\n    cwd,\n    encoding: 'utf8',\n    env: { ...process.env },\n    // snyk test exits 1 on findings — don't throw, capture output\n    stdio: ['pipe', 'pipe', 'pipe'],\n  };\n\n  let raw: string;\n  try {\n    raw = execSync('snyk test --json', opts);\n  } catch (err: unknown) {\n    // Exit code 1 means vulnerabilities found — stdout still has JSON\n    const execError = err as { stdout?: string };\n    raw = execError.stdout ?? '{}';\n  }\n\n  const report = JSON.parse(raw) as SnykReport;\n\n  const highs = report.vulnerabilities.filter(\n    (v) => v.severity === 'high' || v.severity === 'critical'\n  );\n\n  if (highs.length > 0) {\n    console.error(`Found ${highs.length} high/critical vulnerabilities:`);\n    for (const v of highs) {\n      console.error(`  [${v.severity.toUpperCase()}] ${v.title} in ${v.packageName}@${v.version}`);\n    }\n  }\n\n  return report;\n}",
+      "notes": "snyk test exits with code 1 when vulnerabilities are found, so execSync throws. Capture stdout from the thrown error — the JSON output is still present. Always check the ok field on the parsed result, not just the exit code."
+    }
+  ],
+  "gotchas": [
+    "Snyk tests count against your monthly limit EVERY time they run. A CI/CD pipeline that runs on every commit to every branch can exhaust 200 free tests in days on an active team. Set CI to test only on PRs or pushes to protected branches.",
+    "Snyk fix (auto-fixing vulnerabilities) can break your app by upgrading transitive dependencies to versions that introduce breaking API changes. Always review Snyk's suggested fixes in a test environment before applying, especially major version upgrades.",
+    "Snyk's severity ratings (Critical, High, Medium, Low) are based on CVSS scores but may differ from the NVD rating. A 'High' vulnerability in Snyk might be exploitable only under specific conditions not applicable to your code path. Review the vulnerability details rather than acting on severity alone."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA (Business+)",
+    "statusPageUrl": "https://status.snyk.io",
+    "notes": "AWS-hosted with global CDN. Vulnerability database is continuously updated as new CVEs are published. CLI operates in offline mode for scanning but requires connectivity to report results."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Industry standard for dependency vulnerability scanning with the best developer integration (IDE plugins, PR checks, auto-fix PRs). The free tier (200 tests/month) is sufficient for small projects. Main friction: test quota consumption in CI/CD, and automated fix PRs can introduce breaking changes.",
+  "alternatives": [],
+  "complementary": ["vercel", "fly-io", "railway"],
+  "bestFor": "Automated dependency vulnerability scanning integrated into your development workflow — CI checks, IDE warnings, and automated fix PRs for known security issues",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}

package/src/entries/storage/cloudinary.json

@@ -0,0 +1,93 @@
+{
+  "name": "Cloudinary",
+  "slug": "cloudinary",
+  "category": "storage",
+  "subcategory": "media-management",
+  "website": "https://cloudinary.com",
+  "description": "Cloudinary is a cloud-based media management platform that handles image and video upload, storage, transformation, optimization, and delivery via CDN. It provides powerful on-the-fly image transformations through URL parameters, making it the standard choice for apps that need dynamic image processing.",
+  "useCases": [
+    {
+      "task": "Upload, store, and serve images and videos via CDN",
+      "fit": "perfect"
+    },
+    {
+      "task": "Resize, crop, and transform images on-the-fly via URL parameters",
+      "fit": "perfect"
+    },
+    {
+      "task": "Optimize images automatically for web performance",
+      "fit": "perfect"
+    },
+    {
+      "task": "Store and process user-uploaded files",
+      "fit": "good"
+    },
+    {
+      "task": "Store arbitrary files like PDFs or binaries",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at cloudinary.com",
+      "Go to Dashboard and find your Cloud Name, API Key, and API Secret",
+      "Set CLOUDINARY_CLOUD_NAME, CLOUDINARY_API_KEY, CLOUDINARY_API_SECRET environment variables",
+      "Alternatively, use the CLOUDINARY_URL env var: cloudinary://API_KEY:API_SECRET@CLOUD_NAME"
+    ],
+    "envVarName": "CLOUDINARY_API_SECRET",
+    "codeSnippet": "import { v2 as cloudinary } from 'cloudinary';\ncloudinary.config({\n  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,\n  api_key: process.env.CLOUDINARY_API_KEY,\n  api_secret: process.env.CLOUDINARY_API_SECRET,\n});"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "25 credits/month (1 credit = 1000 transformations or 1GB storage or 1GB bandwidth)",
+    "startingPrice": "$89/month for 225 credits",
+    "costPer": "Varies by credits consumed; $0.05 per additional credit overage",
+    "pricingUrl": "https://cloudinary.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "500 requests/hour for API operations",
+    "notes": "Delivery (CDN) has no rate limit — only management API operations are rate-limited. Transformations count against your credit quota.",
+    "retryStrategy": "Implement exponential backoff for 429 responses; CDN delivery is separate from management API and has no limits"
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact cloudinary",
+    "importStatement": "import { v2 as cloudinary } from 'cloudinary';",
+    "otherLanguages": ["python", "java", "ruby", "php", "go", "android", "ios"]
+  },
+  "codeExamples": [
+    {
+      "title": "Upload an image",
+      "language": "typescript",
+      "code": "import { v2 as cloudinary } from 'cloudinary';\n\ncloudinary.config({\n  cloud_name: process.env.CLOUDINARY_CLOUD_NAME,\n  api_key: process.env.CLOUDINARY_API_KEY,\n  api_secret: process.env.CLOUDINARY_API_SECRET,\n});\n\n// Upload from file path\nconst result = await cloudinary.uploader.upload('./profile.jpg', {\n  public_id: 'users/user_123/profile',\n  folder: 'users',\n  overwrite: true,\n  resource_type: 'image',\n});\n\nconsole.log('Uploaded URL:', result.secure_url);\nconsole.log('Public ID:', result.public_id);",
+      "notes": "Use public_id to control the URL path. Set overwrite: true to replace existing images. The returned secure_url is the CDN URL for direct use in <img> tags."
+    },
+    {
+      "title": "Transform image via URL",
+      "language": "typescript",
+      "code": "import { v2 as cloudinary } from 'cloudinary';\n\ncloudinary.config({ /* ... */ });\n\n// Generate a URL with transformations — no API call needed!\nconst url = cloudinary.url('users/user_123/profile', {\n  width: 200,\n  height: 200,\n  crop: 'fill',\n  gravity: 'face', // Auto-detect and center on face\n  quality: 'auto',\n  fetch_format: 'auto', // Serve WebP to browsers that support it\n});\n\nconsole.log('Transformed URL:', url);\n// Outputs: https://res.cloudinary.com/your-cloud/image/upload/w_200,h_200,c_fill,g_face,q_auto,f_auto/users/user_123/profile",
+      "notes": "Transformations are applied on-the-fly and cached at the CDN edge. No server-side processing required — just build the URL."
+    }
+  ],
+  "gotchas": [
+    "Cloudinary's credit system is confusing — storage, bandwidth, AND transformations all consume credits at different rates. Monitor your dashboard carefully to avoid unexpected charges, especially if you have many unique transformations.",
+    "Upload signatures are required for secure client-side uploads. Never expose your API Secret in frontend code. Use cloudinary.utils.api_sign_request() server-side to generate upload signatures.",
+    "Every unique transformation URL is a separate cached variant. If you programmatically generate many transformation combinations, you can quickly exhaust your transformation quota. Stick to a fixed set of transformation presets.",
+    "The free tier's 25 credits/month sounds generous but goes quickly. 1GB of images stored + delivered = 2 credits. Plan your usage carefully."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.99% uptime SLA on paid plans",
+    "statusPageUrl": "https://status.cloudinary.com",
+    "notes": "Global CDN with 180+ PoPs. Images are replicated across multiple regions automatically. Management API has occasional latency spikes."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Best media management platform with unmatched transformation capabilities. URL-based transformations are genuinely magical. TypeScript SDK has some rough edges. Pricing model is complex and can surprise developers. Still the default choice for any app with significant media needs.",
+  "alternatives": ["uploadthing", "aws-s3", "cloudflare-r2", "digital-ocean-spaces", "imgix", "mux"],
+  "complementary": ["openai", "anthropic"],
+  "bestFor": "Image and video management with on-the-fly transformations, auto-optimization, and global CDN delivery",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-1"
+}

package/src/entries/storage/uploadthing.json

@@ -0,0 +1,90 @@
+{
+  "name": "UploadThing",
+  "slug": "uploadthing",
+  "category": "storage",
+  "subcategory": "file-uploads",
+  "website": "https://uploadthing.com",
+  "description": "UploadThing is a developer-friendly file upload service designed primarily for Next.js applications. It provides end-to-end type-safe file uploads with automatic storage, a built-in file router, and seamless integration with React and Next.js — all without needing to configure S3 buckets or cloud storage directly.",
+  "useCases": [
+    {
+      "task": "Add file uploads to a Next.js application",
+      "fit": "perfect"
+    },
+    {
+      "task": "Upload user profile pictures and attachments",
+      "fit": "perfect"
+    },
+    {
+      "task": "Handle document uploads (PDFs, Word files) in a web app",
+      "fit": "good"
+    },
+    {
+      "task": "Complex media transformations like Cloudinary",
+      "fit": "partial"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Sign up at uploadthing.com",
+      "Create a new app in the dashboard",
+      "Copy your UPLOADTHING_TOKEN from the dashboard",
+      "Set UPLOADTHING_TOKEN environment variable",
+      "Install the SDK and configure your file router (see code example)"
+    ],
+    "envVarName": "UPLOADTHING_TOKEN",
+    "codeSnippet": "import { createUploadthing } from 'uploadthing/next';\nconst f = createUploadthing();"
+  },
+  "pricing": {
+    "model": "freemium",
+    "freeTier": "2GB storage, 2GB bandwidth/month",
+    "startingPrice": "$10/month for 100GB storage, 100GB bandwidth",
+    "costPer": "$0.10/GB storage/month, $0.10/GB bandwidth after plan limits",
+    "pricingUrl": "https://uploadthing.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "free tier",
+    "limit": "2GB storage, 2GB bandwidth/month; file size limits configurable per route",
+    "notes": "Individual file size limit is set in your file router (maxFileSize option). Default is 4MB per file.",
+    "retryStrategy": "UploadThing handles retries internally. For server-side uploads, implement standard exponential backoff."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact uploadthing @uploadthing/react",
+    "importStatement": "import { createUploadthing } from 'uploadthing/next';",
+    "otherLanguages": ["solid", "svelte", "vue"]
+  },
+  "codeExamples": [
+    {
+      "title": "Configure file router (Next.js App Router)",
+      "language": "typescript",
+      "code": "// app/api/uploadthing/core.ts\nimport { createUploadthing, type FileRouter } from 'uploadthing/next';\nimport { auth } from '@clerk/nextjs/server'; // or your auth provider\n\nconst f = createUploadthing();\n\nexport const ourFileRouter = {\n  profileImageUploader: f({ image: { maxFileSize: '4MB', maxFileCount: 1 } })\n    .middleware(async () => {\n      const { userId } = await auth();\n      if (!userId) throw new Error('Unauthorized');\n      return { userId }; // Passed to onUploadComplete\n    })\n    .onUploadComplete(async ({ metadata, file }) => {\n      console.log('Upload complete for user:', metadata.userId);\n      console.log('File URL:', file.url);\n      return { uploadedBy: metadata.userId };\n    }),\n} satisfies FileRouter;\n\nexport type OurFileRouter = typeof ourFileRouter;",
+      "notes": "Create the route handler at app/api/uploadthing/route.ts using createRouteHandler({ router: ourFileRouter }). The middleware runs server-side before upload."
+    },
+    {
+      "title": "Upload component (React)",
+      "language": "typescript",
+      "code": "// components/FileUploader.tsx\n'use client';\n\nimport { UploadButton } from '@uploadthing/react';\nimport type { OurFileRouter } from '@/app/api/uploadthing/core';\n\nexport function ProfileImageUploader() {\n  return (\n    <UploadButton<OurFileRouter, 'profileImageUploader'>\n      endpoint=\"profileImageUploader\"\n      onClientUploadComplete={(res) => {\n        console.log('Files:', res);\n        alert('Upload complete!');\n      }}\n      onUploadError={(error: Error) => {\n        alert(`Upload error: ${error.message}`);\n      }}\n    />\n  );\n}",
+      "notes": "UploadButton is a pre-built React component. Use UploadDropzone for drag-and-drop. The file router type ensures full end-to-end type safety."
+    }
+  ],
+  "gotchas": [
+    "UploadThing is tightly integrated with Next.js and the App Router. Using it with other frameworks (Express, Fastify) requires more manual setup and is less well-documented.",
+    "Files are stored on UploadThing's infrastructure (Cloudflare R2 backed) — there is no option to bring your own S3 bucket on standard plans. Enterprise plans may differ.",
+    "The free tier (2GB storage) is very limited for production applications with user-uploaded content. Budget for storage costs early.",
+    "The UPLOADTHING_SECRET/UPLOADTHING_TOKEN format changed in recent SDK versions. Make sure you're using the format matching your SDK version."
+  ],
+  "reliability": {
+    "uptimeGuarantee": null,
+    "statusPageUrl": "https://status.uploadthing.com",
+    "notes": "UploadThing uses Cloudflare R2 as its backing storage. Generally very reliable. Smaller team than Cloudinary so issues take longer to resolve."
+  },
+  "qualityScore": 7,
+  "qualityJustification": "Excellent Next.js integration with type-safe file router pattern — the best developer experience for file uploads in the Next.js ecosystem. Limited to file upload/storage only (no transformations). Free tier is small. Score reflects excellent DX for its specific use case.",
+  "alternatives": ["cloudinary"],
+  "complementary": ["clerk", "openai"],
+  "bestFor": "Simple, type-safe file uploads in Next.js applications without the overhead of configuring cloud storage",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-1"
+}

package/src/entries/testing/browserstack.json

@@ -0,0 +1,86 @@
+{
+  "name": "BrowserStack",
+  "slug": "browserstack",
+  "category": "testing",
+  "subcategory": "cross-browser-testing",
+  "website": "https://www.browserstack.com",
+  "description": "BrowserStack provides real device and browser cloud for automated and manual testing. Run Selenium, Playwright, Cypress, and Appium tests on 3,000+ real browsers and mobile devices without maintaining your own device farm. Integrates with CI/CD pipelines (GitHub Actions, Jenkins, CircleCI).",
+  "useCases": [
+    {
+      "task": "Run automated Playwright or Cypress tests on real browsers in CI",
+      "fit": "perfect"
+    },
+    {
+      "task": "Test a web app on mobile devices (iOS, Android) without owning devices",
+      "fit": "perfect"
+    },
+    {
+      "task": "Debug browser-specific layout issues with live interactive sessions",
+      "fit": "good"
+    }
+  ],
+  "auth": {
+    "method": "api_key",
+    "setupSteps": [
+      "Create a BrowserStack account at browserstack.com",
+      "Navigate to the Automate product dashboard",
+      "Go to Settings in the top-right menu",
+      "Copy your Username and Access Key from the Automate section",
+      "Set BROWSERSTACK_USERNAME and BROWSERSTACK_ACCESS_KEY as environment variables"
+    ],
+    "envVarName": "BROWSERSTACK_USERNAME",
+    "codeSnippet": "// Set credentials as environment variables\n// BROWSERSTACK_USERNAME=your_username\n// BROWSERSTACK_ACCESS_KEY=your_access_key\n\nimport { chromium } from 'playwright';\n\nconst browser = await chromium.connect(\n  `wss://cdp.browserstack.com/playwright?caps=${encodeURIComponent(JSON.stringify({\n    browser: 'chrome',\n    browser_version: 'latest',\n    os: 'Windows',\n    os_version: '11',\n    'browserstack.username': process.env.BROWSERSTACK_USERNAME,\n    'browserstack.accessKey': process.env.BROWSERSTACK_ACCESS_KEY,\n  }))}`\n);"
+  },
+  "pricing": {
+    "model": "paid",
+    "freeTier": "Free trial: 100 minutes of Automate and 100 minutes of App Automate",
+    "startingPrice": "$38/month (Automate Starter) for 1 parallel test, 100 minutes/month",
+    "costPer": null,
+    "pricingUrl": "https://www.browserstack.com/pricing"
+  },
+  "rateLimits": {
+    "tier": "Starter plan",
+    "limit": "1 parallel session (Starter), up to 1,000 parallel sessions (Enterprise). Session length max: 3 hours (Automate)",
+    "notes": "Session queues when all parallels are in use. Idle sessions timeout after 90 seconds of no commands. Tests must send keep-alive commands during long operations.",
+    "retryStrategy": "Implement test-level retry for flaky network issues. BrowserStack sessions auto-terminate after 90s idle to avoid consuming minutes."
+  },
+  "sdk": {
+    "primaryLanguage": "typescript",
+    "installCommand": "npm install --save-exact @playwright/test browserstacklocal",
+    "importStatement": "import { chromium } from 'playwright';",
+    "otherLanguages": ["python", "java", "ruby", "php"]
+  },
+  "codeExamples": [
+    {
+      "title": "Run Playwright test on BrowserStack",
+      "language": "typescript",
+      "code": "import { test, expect } from '@playwright/test';\nimport { chromium } from 'playwright';\n\ntest('homepage loads on BrowserStack Chrome', async () => {\n  const caps = {\n    browser: 'chrome',\n    browser_version: 'latest',\n    os: 'Windows',\n    os_version: '11',\n    name: 'Homepage smoke test',\n    build: `CI build ${process.env.GITHUB_RUN_NUMBER ?? 'local'}`,\n    'browserstack.username': process.env.BROWSERSTACK_USERNAME!,\n    'browserstack.accessKey': process.env.BROWSERSTACK_ACCESS_KEY!,\n  };\n\n  const browser = await chromium.connect(\n    `wss://cdp.browserstack.com/playwright?caps=${encodeURIComponent(JSON.stringify(caps))}`\n  );\n\n  const page = await browser.newPage();\n  await page.goto('https://example.com');\n\n  await expect(page).toHaveTitle(/Example Domain/);\n  await browser.close();\n});",
+      "notes": "Pass build and name caps to group test results in the BrowserStack Automate dashboard. The GITHUB_RUN_NUMBER env var ties results to a specific CI run. Always close the browser to release the parallel session immediately."
+    },
+    {
+      "title": "Configure BrowserStack in playwright.config.ts",
+      "language": "typescript",
+      "code": "import { defineConfig, devices } from '@playwright/test';\n\nexport default defineConfig({\n  testDir: './tests',\n  timeout: 60_000,\n  use: {\n    // BrowserStack Playwright CDPendpoint\n    connectOptions: {\n      wsEndpoint: `wss://cdp.browserstack.com/playwright?caps=${encodeURIComponent(\n        JSON.stringify({\n          browser: 'chrome',\n          browser_version: 'latest',\n          os: 'OS X',\n          os_version: 'Sonoma',\n          'browserstack.username': process.env.BROWSERSTACK_USERNAME,\n          'browserstack.accessKey': process.env.BROWSERSTACK_ACCESS_KEY,\n          build: process.env.GITHUB_SHA ?? 'local',\n          project: 'my-app',\n        })\n      )}`,\n    },\n  },\n  projects: [\n    {\n      name: 'chrome-windows',\n      use: { ...devices['Desktop Chrome'] },\n    },\n    {\n      name: 'safari-mac',\n      use: { ...devices['Desktop Safari'] },\n    },\n  ],\n});",
+      "notes": "Centralise the BrowserStack connection in playwright.config.ts so individual test files stay browser-agnostic. Use process.env.GITHUB_SHA as the build identifier to correlate results with commits in the BrowserStack dashboard."
+    }
+  ],
+  "gotchas": [
+    "BrowserStack sessions have a hard 90-second idle timeout. If your test has a page.waitForNavigation() or sleep that takes over 90 seconds without sending any WebDriver command, the session is killed and your test reports a 'Session not found' error. Send intermediate commands or reduce idle time.",
+    "Local testing (testing localhost or internal staging URLs) requires the BrowserStackLocal binary running as a tunnel daemon. The binary must be started before the test and stopped after. Forgetting to start the tunnel is one of the most common CI failures.",
+    "BrowserStack test minutes are consumed even for failed tests. A flaky test suite that retries 3x will consume 3x the minutes. Optimize your test suite to reduce reruns, and use BrowserStack's test reporting to identify flaky tests.",
+    "The free trial limits (100 minutes) are consumed quickly — a typical Playwright test suite takes 2-5 minutes per test. 100 minutes covers 20-50 tests total. Plan your budget before converting to a paid plan."
+  ],
+  "reliability": {
+    "uptimeGuarantee": "99.9% uptime SLA",
+    "statusPageUrl": "https://status.browserstack.com",
+    "notes": "Global device cloud infrastructure with redundant device pools. BrowserStack maintains physical devices across multiple data centers to ensure availability."
+  },
+  "qualityScore": 8,
+  "qualityJustification": "Industry standard for cross-browser and cross-device testing. 3,000+ real devices is genuinely useful — no other service comes close for mobile device coverage. Playwright and Cypress integrations are well-maintained. Main friction: expensive at scale, and session timeouts require careful test design.",
+  "alternatives": ["checkly"],
+  "complementary": ["vercel", "netlify"],
+  "bestFor": "Running automated end-to-end tests on real browsers and mobile devices across your CI/CD pipeline without maintaining a device farm",
+  "lastVerified": "2026-02-25",
+  "entryVersion": 1,
+  "addedBy": "claude-code-session-4"
+}