ESCIMate API

Cold-start warning: the production server (Render free tier) sleeps after 15 minutes of inactivity. The first request after idle may take ~76 seconds. Probe /health first to wake the server.

No authentication required. No API keys. No rate limiting at the API level — but Plumber is single-threaded, so concurrent requests are queued.

1. 1. Quick Start
2. 2. Endpoints
3. 3. Configuration Options
4. 4. Response Format
5. 5. Status Taxonomy
6. 6. Effect Size Families
7. 7. R Package API
8. 8. Tolerance Defaults
9. 9. Error Handling
10. 10. Limits & Performance

Health check:

curl https://escimate.app/health

Analyze a PDF file:

curl -X POST https://escimate.app/api/v1/process \
  -F "file=@paper.pdf"

Analyze pasted text:

curl -X POST https://escimate.app/api/v1/process-text \
  -H "Content-Type: application/json" \
  -d '{"text": "t(28) = 2.21, p = .035, d = 0.80"}'

Analyze text with custom options:

curl -X POST https://escimate.app/api/v1/process-text \
  -H "Content-Type: application/json" \
  -d '{
    "text": "F(1, 58) = 7.23, p = .009, eta2 = .11",
    "options": {
      "alpha": 0.05,
      "one_tailed": false,
      "cross_type_action": "NOTE",
      "stats": ["t", "F", "r", "chisq"]
    }
  }'

Generate an HTML report (file or text):

curl -X POST "https://escimate.app/api/v1/report?style=beginner" \
  -F "file=@paper.pdf" \
  -o report.html

curl -X POST https://escimate.app/api/v1/report-text \
  -H "Content-Type: application/json" \
  -d '{"text": "t(28) = 2.21, p = .035, d = 0.80", "style": "expert"}' \
  -o report.html

Compare with statcheck:

curl -X POST https://escimate.app/api/v1/compare \
  -F "file=@paper.pdf"

curl -X POST https://escimate.app/api/v1/compare-text \
  -H "Content-Type: application/json" \
  -d '{"text": "t(28) = 2.21, p = .035, d = 0.80"}'

Python example:

import requests

# From text
r = requests.post(
    "https://escimate.app/api/v1/process-text",
    json={"text": "t(28) = 2.21, p = .035, d = 0.80",
          "options": {"alpha": 0.05}},
    timeout=120,
)
data = r.json()
for row in data["results"]:
    print(row["test_type"], row["status"], row.get("delta_effect"))

# From file
with open("paper.pdf", "rb") as f:
    r = requests.post(
        "https://escimate.app/api/v1/process",
        files={"file": f},
        data={"options": '{"alpha": 0.01}'},
        timeout=300,
    )
print(r.json()["summary"])

JavaScript / Node example:

// From text
const res = await fetch("https://escimate.app/api/v1/process-text", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    text: "t(28) = 2.21, p = .035, d = 0.80",
    options: { alpha: 0.05 },
  }),
})
const data = await res.json()
console.log(data.summary)

// From file (browser)
const fd = new FormData()
fd.append("file", fileInput.files[0])
fd.append("options", JSON.stringify({ alpha: 0.05 }))
await fetch("https://escimate.app/api/v1/process", { method: "POST", body: fd })

Pass via the options object (text endpoints) or as a JSON-encoded options form field (file endpoints).

Additional R-only parameters (ci_level, paired_r_grid, tol_ci, tol_p, max_text_length, max_stats_per_text, ci_method_phi, ci_method_V, messages) are documented in API.md.

Process endpoints return:

{
  "results": [ /* one object per detected statistic */ ],
  "normalized_text": "Full text after Unicode normalization...",
  "summary": {
    "total": 12,
    "pass": 8,
    "ok": 2,
    "note": 1,
    "warn": 0,
    "error": 1,
    "extraction_suspect_count": 0,
    "cross_type_count": 0
  },
  "effectcheck_version": "0.3.5"
}

Each results[] object includes 50+ fields across these groups:

• Identification — location, raw_text, context_window, test_type, source
• Parsed values — df1, df2, stat_value, N, n1, n2, table_r, table_c
• Reported values — reported_type, effect_reported, ciL_reported, ciU_reported, p_reported, p_symbol, p_valid, N_source
• Type-matched comparison — matched_variant, matched_value, delta_effect, ambiguity_level, all_variants (JSON)
• Computed effect sizes — d_ind, g_ind, dz, dav, drm, eta2, partial_eta2, omega2, cohens_f, phi, V, rank_biserial_r, cliffs_delta, epsilon_squared, kendalls_W, standardized_beta, partial_r, …
• P-value & decision error — p_computed, decision_error, decision_error_reason
• CI comparison — ci_match, ciL_computed, ciU_computed, ci_delta_lower, ci_delta_upper, ci_check_status, ci_method_match, ci_width_ratio, ci_symmetry, ci_level_source
• v0.3.5 CI audit — effect_reported_decimals, ciL_reported_decimals, ciU_reported_decimals, stat_value_decimals, ci_expected, ci_reported, ci_level_mismatch, ci_clipped_to_bound, ci_symmetry_class
• Reproducibility — repro_code, repro_output
• Status & metadata — status, check_type, extraction_suspect, design_ambiguous, design_inferred, variants_tested, uncertainty_level, uncertainty_reasons, assumptions_used, insufficient_data

Field-level documentation also lives in the R package's function help: ?effectcheck::check_text.

Modifiers: decision error escalates to ≥ WARN; CI mismatch downgrades PASS → NOTE (when ci_affects_status); plausibility filter downgrades ERROR → NOTE; design-ambiguous t-test ERROR downgrades to design_ambiguous_action.

Install from CRAN (recommended) or GitHub:

# Stable release from CRAN
install.packages("effectcheck")

# Or development version from GitHub
# install.packages("remotes")
remotes::install_github("giladfeldman/escicheck")

Core functions:

library(effectcheck)

# From text
res <- check_text("t(28) = 2.21, p = .035, d = 0.80")
print(res); summary(res)

# Single file
res <- check_file("paper.pdf", alpha = 0.01)

# Whole directory (recursive)
res <- check_dir("manuscripts/", stats = c("t", "F"))

# HTML report
generate_report(res, out = "report.html", style = "beginner")

# statcheck side-by-side
cmp <- compare_with_statcheck("t(28) = 2.21, p = .035, d = 0.80")

statcheck-compatible wrappers also exported: checkPDF(), checkHTML(), checkPDFdir(), checkHTMLdir(), checkDOCXdir().

Plausibility bounds: |d|, |g|, |cohens_f|, |beta| > 10; |r|, |phi|, |V|, |R2|, |eta2|, |omega2|, |rank_biserial_r|, |cliffs_delta|, |epsilon_squared|, |kendalls_W| > 1; |OR|, |RR|, |IRR| > 100; |h| > 3.15. Any effect size delta > 1.0 is flagged as a likely extraction error.

JSON endpoints return { "error": "message" }. HTML report endpoints return an HTML error page.

CORS allows: localhost:2249/3000, 127.0.0.1:2249/3000, escimate.app, www.escimate.app, *.vercel.app. Non-browser requests (no Origin) get *.

No rate limiting at the API level. Be considerate — this is a free academic service. For heavy batch use, run the R package or self-host with the Docker image (see GitHub).

The effectcheck R package is open-source on GitHub and CRAN — the same engine that powers this API. For local or batch use without going through the hosted API, install the R package and call check_text() / check_file() / check_dir() directly. The hosted web service (frontend, deployment glue) is not open-source.