How do I sign up for LiquidMetal AI and deploy a first API on the PAYG plan?

Quick Answer: To sign up for LiquidMetal AI on the PAYG plan, create an account, choose usage-based billing, and grab your Raindrop API credentials. From there, you can use Raindrop’s CLI to scaffold, build, and deploy your first intelligent API in minutes—without stitching together separate databases, auth, or scaling infrastructure.

Most teams asking how to sign up for LiquidMetal AI and deploy a first API on the PAYG plan are trying to answer a simple question: “How fast can I go from idea to a production backend that I can bill and monitor?” This guide walks step-by-step from account creation to a live, pay-as-you-go Raindrop API, using the same workflow I use when testing new agent backends internally.

---

Why This Matters

If you’ve ever tried to put an AI agent or RAG workflow in production, you know the pain: you wire up a model, a vector DB, some storage, a database, auth middleware, billing, and a thin HTTP layer. Then you have to scale it, observe it, and keep track of versions. Shipping a simple “first API” often turns into a week of glue work.

LiquidMetal AI’s Raindrop runtime cuts that down to minutes:

• You sign up.
• You pick PAYG so you only pay for what you use.
• You define or describe an API, and Raindrop builds, tests, and deploys it with SmartMemory, SmartBuckets, SmartSQL, and SmartInference wired in.
• You get observability, versioning, and global scaling from day one.

Answering “how do I sign up for LiquidMetal AI and deploy a first API on the PAYG plan?” is really about collapsing time-to-production while keeping production guarantees: isolation, logging, rollback, and predictable costs.

Key Benefits:

• Frictionless signup → first deployment in minutes: Account, CLI, manifest/description, deploy. No manual infra setup or key juggling across services.
• PAYG cost model → safe experimentation: Start on free included usage (tokens + storage), then pay only for what your API actually consumes—no egress fees, no idle cluster costs.
• Production-grade from day one: Smart primitives, built-in auth and monetization, complete versioning, and full observability mean your “first API” is already product-ready.

---

Core Concepts & Key Points

Concept	Definition	Why it's important
Raindrop Runtime	LiquidMetal AI’s AI-native runtime for backend APIs, designed to ship intelligent, stateful APIs quickly.	Gives you a unified environment for agents, RAG, and standard APIs—no stitching together serverless, DBs, and vector infra.
Smart Primitives	Built-in capabilities like SmartMemory, SmartBuckets, SmartSQL, and SmartInference that treat intelligence and state as first-class.	You get storage, embeddings, memory, and model routing without extra services; your first PAYG API is ready for real workloads.
PAYG Plan	Usage-based billing for tokens and storage, with free baseline usage and no egress fees.	Lets you deploy and iterate on your first API at low risk and scale up naturally as traffic and usage grow.

---

How It Works (Step-by-Step)

At a high level, the path from “how do I sign up for LiquidMetal AI and deploy a first API on the PAYG plan?” to a live endpoint looks like this:

1. Create a LiquidMetal AI account and select PAYG.
2. Install the Raindrop CLI and authenticate with your API credentials.
3. Choose Developer Mode (manifest-driven) or AI Mode (describe in English), then build and deploy your first Raindrop API.

Below is the detailed flow I’d use as a production engineer.

---

1. Create Your LiquidMetal AI Account on PAYG

1. Go to the signup page:
   https://liquidmetal.run/r/sign-up (redirects from liquidmetal.ai).
2. Create an account with your email or SSO provider.
3. During onboarding, choose the pay-as-you-go / usage-based option:
   • You’ll get free 2M tokens + 10GB storage per month included.
   • Additional tokens and storage are charged as you use them.
   • No egress fees, which matters if your APIs ship a lot of data out to clients or other services.

Choosing PAYG at signup is what keeps your “first API” low-risk: you don’t need to estimate traffic or pre-allocate capacity—Raindrop scales automatically and you pay only for what your endpoints actually consume.

---

2. Get Your API Credentials

After signup:

1. Navigate to your Dashboard.
2. Locate the API Keys / Credentials section.
3. Create a new API key specifically for your first Raindrop project.
   • Give it a clear name (e.g., first-payg-api).
   • Restrict permissions if you’re testing in a shared environment.
4. Copy the key and keep it somewhere secure (e.g., local .env file, vault).

Raindrop uses these credentials to authenticate your CLI and any automation that builds, tests, and deploys APIs. They also plug into built-in auth and billing so you can expose your own API with JWT, OAuth, RBAC, and API keys later.

---

3. Install the Raindrop CLI

On your local machine or dev environment, install the Raindrop CLI:

npm install -g @liquidmetal-ai/raindrop

This CLI is how you interact with the AI-native runtime:

• Define and manage Raindrop projects.
• Build and deploy APIs to production.
• Integrate with MCP-based agents (Claude Code, Gemini CLI) if you want an AI to build the app for you.

If you want to let an agent build your first API:

# Claude Code integration
raindrop mcp install-claude

# Gemini CLI integration
raindrop mcp install-gemini

For now, we’ll stay CLI-first so you see exactly what’s happening.

---

4. Authenticate the CLI With Your PAYG Account

In your terminal:

raindrop login

Follow the prompts:

• Paste your API key from the dashboard.
• Confirm the workspace / organization you want to use for this first PAYG deployment.

Once authenticated, the CLI knows which account (and billing mode) to use. All build and deploy operations for your first API will be charged against your PAYG plan and will show up in your usage metrics.

---

5. Choose Your Build Path: Developer Mode vs AI Mode

Raindrop gives you two paths to ship your first API:

• Developer Mode – you write a simple manifest that defines endpoints, SmartMemory, SmartBuckets, SmartSQL, and SmartInference usage.
• AI Mode – you describe what you need in plain English, and Raindrop’s AI builds, tests, and deploys a complete API.

For “how do I sign up for LiquidMetal AI and deploy a first API on the PAYG plan?”, I recommend Developer Mode for full clarity, then AI Mode once you’re comfortable.

---

6. Create a New Raindrop Project (Developer Mode)

In an empty directory:

mkdir first-payg-api
cd first-payg-api

Initialize a Raindrop project:

raindrop init

This will create a skeleton with:

• A manifest file defining your API (endpoints, auth, smart primitives).
• Any supporting code or config Raindrop needs.

Think of the manifest as the “source of truth” for your backend. Raindrop will fully version it, along with associated data and primitives, so you can roll back any change.

---

7. Define a Simple Intelligent Endpoint

Let’s define a single endpoint that uses SmartInference to call one of the 60+ models, and stores request/response history in SmartMemory so you can treat it like a chat session later.

A minimal manifest might look like this (pseudo-structure; adapt to current Raindrop manifest schema):

service:
  name: first-payg-api
  description: Simple intelligent endpoint on PAYG
  auth:
    mode: api_key  # Later you can enable JWT/OAuth/RBAC
  routes:
    - path: /summarize
      method: POST
      handler: summarizeHandler
      smart_primitives:
        memory:
          type: SmartMemory
          scope: session

smart_primitives:
  inference:
    default_model: claude-3.5-sonnet  # example; pick any supported model
  memory:
    sessions:
      type: SmartMemory
      mode: working_and_episodic

actors: []

Then in your handler (TypeScript/JS example):

import { SmartInference, SmartMemory } from "@liquidmetal-ai/raindrop";

export async function summarizeHandler(req, ctx) {
  const { text } = await req.json();

  // Store original text in SmartMemory
  await SmartMemory.append({
    sessionId: ctx.sessionId,
    type: "input",
    content: text,
  });

  // Call SmartInference
  const summary = await SmartInference.generate({
    prompt: `Summarize the following text in 3 bullet points:\n\n${text}`,
  });

  // Store output in SmartMemory
  await SmartMemory.append({
    sessionId: ctx.sessionId,
    type: "output",
    content: summary,
  });

  return new Response(JSON.stringify({ summary }), {
    headers: { "Content-Type": "application/json" },
  });
}

What this gives you on PAYG:

• SmartInference → you’re billed per token used, no need to integrate a separate model vendor.
• SmartMemory → persistent session state “built in, not bolted on,” no separate DB or cache.
• Versioned API → this manifest and handler are fully versioned; you can roll back safely.

---

8. Build the API With the Raindrop CLI

From your project root:

raindrop build create

This command:

• Validates your manifest and code.
• Wires in SmartMemory, SmartInference, and any other primitives you declared.
• Runs tests (if provided).
• Produces a fully-versioned build artifact that Raindrop can deploy.

Because you’re on the PAYG plan, the build’s resource usage is tracked but you’re not on the hook for idle infrastructure; Raindrop will scale the runtime as needed.

---

9. Deploy to Production

After a successful build:

raindrop deploy

The CLI will:

• Deploy your API to the Raindrop runtime.
• Provision global scaling and routing.
• Attach built-in observability.
• Respect your auth configuration (API key, JWT, OAuth, RBAC, etc.).

You’ll get a deployed URL back, something like:

https://api.raindrop.run/v1/first-payg-api

Your /summarize endpoint is now ready for traffic, billed via PAYG:

curl -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{"text": "Long document content..."}' \
  https://api.raindrop.run/v1/first-payg-api/summarize

---

10. Monitor Usage, Costs, and Behavior

Back in the LiquidMetal dashboard:

• View usage metrics:
  • Tokens consumed via SmartInference (counts against your free 2M tokens then PAYG).
  • SmartMemory reads/writes.
  • Storage in SmartBuckets (if you add them later).
• Inspect logs and traces:
  • Every AI decision is logged and traceable.
  • You can drill into specific requests for debugging and audits.
• Manage versions:
  • See which manifest build is live.
  • Roll back or roll forward with confidence if you change handlers or primitives.

This is where using LiquidMetal AI for your first PAYG API pays off: you get full observability and versioning from day one, not bolted on later.

---

Common Mistakes to Avoid

• Treating Raindrop like “just serverless”:
  Don’t wire external DBs and vector stores before you need to. Use SmartMemory, SmartBuckets, and SmartSQL first—intelligence and state are built in, not bolted on.

• Skipping versioning discipline:
  Avoid making ad-hoc changes without tracking builds. Always go through raindrop build create and use the dashboard to manage versions and rollbacks so you can explain exactly what changed and why.

• Ignoring auth and monetization from day one:
  It’s tempting to keep your first API “open.” Instead, configure API keys or JWT now and plan for built-in monetization (plans, rate limits, usage tracking) so you can safely expose your endpoint to users.

---

Real-World Example

A small team building a developer-facing documentation assistant needed to move from a prototype notebook to a billable API. They asked essentially the same question: how do I sign up for LiquidMetal AI and deploy a first API on the PAYG plan without building a full backend?

They followed this path:

1. Signed up via the PAYG signup link and used the free 2M tokens + 10GB storage for initial experiments.
2. Installed the Raindrop CLI and authenticated with a project-specific API key.
3. Defined a single /answer endpoint in the manifest:
   • SmartBuckets handled documentation storage with automatic vector embeddings and semantic search.
   • SmartMemory held conversation history per user.
   • SmartInference routed queries to a high-quality model.
4. Ran raindrop build create and raindrop deploy to ship it.
5. Enabled API key auth and wired the endpoint into their web app.
6. Used the dashboard to:
   • Monitor token usage as real users arrived.
   • Catch and debug edge cases via full traces.
   • Roll out new versions safely when they refined prompts and retrieval logic.

They never touched a separate vector database, didn’t manage servers, and still shipped a production-ready, billable API within a day—paying only for the tokens and storage they actually used.

Pro Tip: For your first PAYG API, start with a single endpoint and one or two smart primitives (e.g., SmartInference + SmartMemory). Once you see the observability and costs in the dashboard, you can layer in SmartBuckets and SmartSQL without re-architecting your backend.

---

Summary

To answer “how do I sign up for LiquidMetal AI and deploy a first API on the PAYG plan?” concretely:

• Sign up at https://liquidmetal.run/r/sign-up and choose the pay-as-you-go plan, leveraging free tokens and storage plus no egress fees.
• Install and authenticate the Raindrop CLI with your API credentials so you can manage builds and deployments from your terminal.
• Define a simple API in Developer Mode (or describe it in AI Mode) using smart primitives like SmartInference and SmartMemory, then run raindrop build create and raindrop deploy to ship it.
• Monitor and iterate using full observability, complete versioning, and built-in auth/monetization—so even your “first API” is safe, traceable, and ready for real users.

You end up with an intelligent, stateful, globally scalable API that you can evolve from experiment to product without throwing away your architecture.

---

Next Step

Get Started