How do I sign up for ZeroEntropy and create an API key to start testing?

Most teams want to know one thing first: how fast can I get from “curious about ZeroEntropy” to “running real queries against my data”? The answer is: a few minutes. You sign up, create an API key in the dashboard, drop it into the SDK, and you’re testing rerankers, embeddings, or the Search API right away.

Quick Answer: Create an account at https://dashboard.zeroentropy.dev, generate an API key from the dashboard, and plug it into the ZeroEntropy SDK or HTTP calls to start testing reranking, embeddings, and search in minutes.

Frequently Asked Questions

How do I sign up for ZeroEntropy and get my first API key?

Short Answer: Go to https://dashboard.zeroentropy.dev, create an account, then generate an API key from the dashboard’s API Keys section to start calling the ZeroEntropy API.

Expanded Explanation:
ZeroEntropy is built to be “API-first,” so your entire testing and integration flow starts from the dashboard. Once you’ve signed up with your work email and confirmed it, you’ll land in a developer-focused UI where you can create one or more API keys tied to your account or organization. Those keys unlock access to zerank-2 (our reranker), zembed-1 (our embeddings), and the Search API in a few lines of code.

Your API key authenticates every request—whether you’re just reranking a list of legal documents, embedding clinical notes, or testing hybrid retrieval for support tickets. You can revoke or rotate keys anytime from the same dashboard, so you keep tight control as you move from local testing to staging and production.

Key Takeaways:

• Sign up at https://dashboard.zeroentropy.dev and confirm your account.
• Create an API key from the dashboard and use it in the SDK or direct HTTP calls to start testing.

---

What’s the step-by-step process to start testing ZeroEntropy?

Short Answer: Sign up, generate an API key, install the SDK, and run a simple rerank or embedding request to validate everything is wired correctly.

Expanded Explanation:
The shortest path to value is: account → API key → test query. You don’t need to stand up a vector DB, tune BM25 weights, or wire an “infra Frankenstein” of services. With a single API key, you can call our rerankers, embeddings, and unified Search API and see how calibrated relevance shifts your NDCG@10 and reduces wasted LLM tokens.

This process is the same whether you’re a solo engineer prototyping RAG for your docs, or an enterprise team benchmarking us against Cohere rerank-3.5 or Jina rerank-m0. The Starter plan includes a free trial period with enough queries and ingestion tokens to validate retrieval quality on your real corpus before you commit.

Steps:

1. Create your account

   • Visit https://dashboard.zeroentropy.dev.
   • Sign up with your email and set a password.
   • Verify your email if prompted to activate the account.

2. Generate an API key

   • Log in to the dashboard.
   • Navigate to the API Keys or equivalent section.
   • Click Create API Key, add a name/label (e.g., local-testing), and save the generated key securely.

3. Run your first request

   • Install the SDK in your language of choice (e.g., Python).
   • Initialize the client with your API key:

     from zeroentropy import ZeroEntropy
     
     zclient = ZeroEntropy(api_key="YOUR_API_KEY")
     

   • Call a simple endpoint (like rerank or embeddings) to confirm everything works.
   • Iterate: wire it into your existing RAG or search stack and compare results.

---

What’s the difference between signing up for the dashboard and using the API key?

Short Answer: The dashboard account is your control plane; the API key is your programmatic access token for calling ZeroEntropy from code.

Expanded Explanation:
Think of the dashboard as where you configure, monitor, and manage, and the API key as what your services use at runtime. You sign up in the dashboard once, and from there you can create multiple API keys with different labels or scopes for dev, staging, and production. The API key then goes into your application config or secrets manager so your code can talk to zerank-2, zembed-1, and the Search API.

You’ll never send your dashboard password in code—only the API key. When you rotate or revoke a key in the dashboard, any system using that key will immediately lose access, which is exactly what you want if a credential leaks or you decommission an environment.

Comparison Snapshot:

• Dashboard Account: Human login; used to create keys, view usage, manage plans, access compliance docs.
• API Key: Machine credential; used in HTTP headers/SDKs to authenticate API calls.
• Best for:
  • Dashboard: admins, tech leads, and engineers managing retrieval at the system level.
  • API Key: services, agents, and RAG pipelines executing queries at machine speed.

---

How do I integrate the API key into my app and start calling ZeroEntropy?

Short Answer: Store the API key as a secret (e.g., environment variable) and pass it into the ZeroEntropy SDK or as an Authorization header in your HTTP requests.

Expanded Explanation:
Once you have the API key, integration is a few lines of code. You don’t need to orchestrate multiple services: our stack already combines dense, sparse, and reranked relevance in a single API. Put your API key into a secure config, initialize the client, and start testing rerank or search on a realistic workload—legal clauses, clinical docs, support tickets, or whatever corpus you care about.

In Python, for example, you can go from “new API key” to “first rerank response” in under a minute. From there, you can benchmark NDCG@10, inspect calibrated scores, and measure p50–p99 latency against your current retrieval setup.

What You Need:

• A secure way to store the key

  • Use environment variables or a secrets manager (AWS Secrets Manager, GCP Secret Manager, Vault).
  • Never hard-code the key in version-controlled files.

• Basic SDK or HTTP setup

  • Example (Python-style):

    import os
    from zeroentropy import ZeroEntropy
    
    zclient = ZeroEntropy(api_key=os.environ["ZEROENTROPY_API_KEY"])
    
    response = zclient.rerank(
        model="zerank-2",
        query="Key indemnification clause for software licensing",
        documents=[
            "Clause 5: Indemnification...",
            "Clause 12: Limitation of liability...",
            "Clause 7: Term and termination..."
        ]
    )
    print(response)
    

  • Or call via HTTPS with Authorization: Bearer YOUR_API_KEY header.

---

How does the free trial work, and what can I test with my API key?

Short Answer: The Starter plan includes a 2‑week free trial with 1,000 queries and 1M ingestion tokens so you can test real retrieval workloads before upgrading.

Expanded Explanation:
To make evaluation straightforward, the Starter plan gives you enough headroom to run meaningful benchmarks, not just toy demos. During the trial, your API key works against the same production-grade rerankers and embeddings we use for paying customers. That means you can:

• Embed and index a representative slice of your corpus.
• Run hybrid retrieval via the Search API.
• Rerank candidate sets with zerank-2 and inspect calibrated zELO scores.
• Measure NDCG@10 and latency distribution (p50/p90/p99) versus your existing stack.

When you hit the trial limits—1,000 queries and 1M ingestion tokens—you can upgrade directly in the dashboard without changing code. Your API key remains valid; only your quota and plan features change.

Why It Matters:

• Realistic evaluation: You can test on your actual legal, medical, finance, or support data instead of synthetic benchmarks.
• Smooth path to production: The same API key and endpoints you use in the free trial can power your production RAG or agent system once you upgrade.

---

Is my data secure when I use my API key in production or testing?

Short Answer: Yes. ZeroEntropy is SOC 2 Type II and HIPAA ready, offers an EU-based managed instance, and supports on-prem/VPC deployment for maximum control.

Expanded Explanation:
Your API key is the entry point to a stack built with enterprise security in mind. We’re SOC 2 Type II and HIPAA ready, so you can integrate ZeroEntropy into regulated workflows (healthcare, finance, legal) without hand-wavy assurances. If you need strict data residency, you can run against a fully managed EU instance; if your policies require full control, ze-onprem lets you deploy the retrieval stack in your own VPC or on-prem environment.

Access to our SOC 2 Type II report and other security documents is available via our compliance portal or by emailing security@zeroentropy.dev. That transparency is important if you’re rolling out retrieval across a large organization or plugging us into customer-facing AI agents where misconfiguration or leakage is not an option.

Why It Matters:

• Enterprise readiness: SOC 2 Type II and HIPAA readiness make it easier to clear security reviews and vendor assessments.
• Flexible deployment: You can start with the hosted API and move to EU-region or on-prem/VPC deployment as your compliance needs evolve, without changing your retrieval logic.

---

Quick Recap

To start testing ZeroEntropy, you sign up at https://dashboard.zeroentropy.dev, generate an API key in the dashboard, and plug it into the SDK or HTTP calls. That single key unlocks access to zerank-2, zembed-1, and the Search API, so you can benchmark hybrid retrieval, calibrated reranking, and latency on your real data—backed by SOC 2 Type II / HIPAA-grade security, EU-region options, and on-prem/VPC deployment when you need it.

Next Step

Get Started