Skip to main content
5 min quickstart

Quickstart guide

Get to a successful first request fast. This page covers account setup, installation, authentication, and one filtered signals query you can build on immediately.

Get key Export env var Make first request

Best For

First-time integrations and anyone who wants a working request before reading the full reference.

You’ll Finish With

An API key, installed client, and one working signals request using the same patterns as the main reference.

Go Next

Move to the API reference for parameters, or examples if you want complete recipes and webhook handlers.

I want raw JSON fast

Use cURL if you just need to verify auth and inspect one live response quickly.

cURL

I am wiring an app

Use the SDK path if you already know this will land inside Python or Node.js code.

Python / Node SDK

I need proof before complexity

Keep the first request small with `limit=1` and no aggressive filters until auth is confirmed.

Minimal first request

Prerequisites

  • Python 3.8+ or Node.js 16+ (or use cURL for direct API access)
  • An EVSignals account (sign up here)
  • Your API key from the dashboard

Verification Checklist

Set EVSIGNALS_API_KEYMake one authenticated requestConfirm at least one returned itemAdd filters only after the first success

Minute 1

Copy your key and put it in EVSIGNALS_API_KEY.

Minute 2

Run one tiny authenticated request with limit=1.

Minute 3+

Add filters, inspect payload fields, then move into the reference or examples.

What this page does

If you only do one thing

Get EVSIGNALS_API_KEY into your environment, run the smallest possible request, and inspect one returned signal before writing any integration logic.

Fastest path

Use an environment variable, make one authenticated request, then expand your filters once that works.

What not to optimize yet

Do not start with webhooks, backtests, or portfolio automation. Confirm auth and response shape first.

Success checklist

  • You can authenticate with EVSIGNALS_API_KEY.
  • You can retrieve at least one page from /v1/signals.
  • You understand the top-level response shape before adding more logic.
1

Get Your API Key

First, get a key from the dashboard and decide whether you are working in test or live mode. Keep the key secret and load it from your environment whenever possible.

Test API Key

Use test keys while wiring up your integration and validating request handling.

evs_test_...
Live API Key

Use live keys when you are ready for production traffic and real data.

evs_live_...
Create Account and Get Key
1a

Set the Environment Variable

Do this before you run the SDK or cURL examples. Keeping credentials in an environment variable is the cleanest way to avoid hardcoding secrets in your codebase.

# Temporary for the current shell session
export EVSIGNALS_API_KEY="evs_test_your_api_key_here"

# Verify it is present
echo "$EVSIGNALS_API_KEY"
2

Install the SDK

Install the SDK if you are integrating from Python or Node.js. If you just want to validate auth and inspect raw JSON, cURL is the shortest path.

# Install via pip
pip install evsignals

# Or with poetry
poetry add evsignals
3

Initialize the Client

Create the client and make a tiny authenticated request. If this step works, your API key, package install, and basic connectivity are all in place.

Before you run it

Shell

Export the API key in the same terminal session that runs your command.

Environment

Use test keys for wiring, live keys only when you need production data.

Scope

Keep the request tiny so failures are easier to isolate.

import os
import evsignals

# Option 1: Use environment variable (recommended)
# Set EVSIGNALS_API_KEY in your environment first:
# export EVSIGNALS_API_KEY="evs_live_your_api_key_here"
client = evsignals.Client()  # Auto-loads from env

# Option 2: Pass API key directly
client = evsignals.Client(
    api_key="evs_live_your_api_key_here"
)

# Make a small authenticated request
signals = client.signals.list(limit=1)
print(f"Authenticated. Retrieved {len(signals.data)} signal(s).")
Recommended: Store your API key in EVSIGNALS_API_KEY and keep your first request small with limit=1.
4

Request Filtered Signals

Once authentication works, request a small page of active signals with a few filters. This mirrors the main reference and gives you a response shape you can safely build around.

Start Small

Use limit=10 or less until you understand the response.

Keep Filters Simple

A couple of markets and one EV threshold are enough for the first pass.

Log Real Payloads

Do not model the response from memory. Inspect a real item first.

# List active signals with a minimum edge
signals = client.signals.list(
    min_ev=0.02,                     # Minimum 2% edge
    markets=["kalshi", "polymarket"],
    status="active",
    limit=10
)

# Process the results
for signal in signals.data:
    print(f"{signal.market} | {signal.contract_name} | {signal.ev_percent}% EV")

Why this request first

  • It confirms your auth flow using a documented endpoint.
  • It keeps the payload small enough to inspect quickly.
  • It introduces the common filters you will reuse later: min_ev, markets, status, and limit.

What to inspect in the response

Core fields

  • id for stable references
  • market and contract_name for display
  • ev_percent and current_price for decision logic

Before moving on

  • Confirm whether the SDK returns data plus pagination metadata.
  • Log one full item once so downstream code is based on the actual payload, not assumptions.
  • Only then add filtering, alerting, or persistence.
5

Set Up Real-Time Alerts (Optional)

Add webhooks after your basic request flow is stable. They are useful once you know which events you want and already have an endpoint ready to verify signatures.

# Set up a webhook for real-time alerts
webhook = client.webhooks.create(
    url="https://yourapp.com/webhooks/evsignals",
    events=["signal.created", "signal.expired"],
)

print(f"Webhook created: {webhook.id}")
print(f"Signing secret: {webhook.secret}")

Quick troubleshooting

401 or authentication error

Double-check the key prefix, confirm the environment variable is exported in the current shell, and make sure you are not mixing test and live credentials.

Empty response set

Lower min_ev, remove filters, or increase limit before assuming the integration is broken.

SDK import or runtime issue

Verify the package actually installed in the active environment, then rerun the smallest possible request before debugging application code.

Webhook confusion

Skip webhooks until your polling flow is working. They add signature verification and endpoint delivery concerns that can hide simpler auth problems.

FAQ

What is the fastest way to verify my integration?

Set EVSIGNALS_API_KEY, make one small authenticated request with limit=1, and inspect the first returned item before adding filters or storage.

Should I start with cURL or an SDK?

Use cURL if you want the shortest path to raw JSON. Use the Python or Node.js SDK if you are already wiring the API into an application.

What should I do if the response is empty?

Reduce or remove filters, lower min_ev, and keep the request small until you confirm the integration is working with real data.

Next Steps

Common progression

Quickstart to confirm auth, API reference to expand filters, SDK docs to harden client behavior, then examples when you want a concrete bot or workflow.

If auth works

Expand filters gradually and confirm the response shape you will actually store or render.

If payload looks right

Move into the API reference for pagination, parameter behavior, and endpoint details.

If you need a real workflow

Use examples once you want alerts, bots, webhook handlers, or backtest-oriented recipes.

What to do after this page