hoppscotch
Open-Source API Development Ecosystem • https://hoppscotch.io • Offline, On-Prem & Cloud • Web, Desktop & CLI • Open-Source Alternative to Postman, Insomnia
- 81k
- TypeScript
- MIT
- 2 d ago
Official Python SDK for doDomain — connect your customers' custom domains.
Repo DevinoSolutions/dodomain-python, read from GitHub 1 min ago. DevinoSolutions has not joined Take My Repo.
DevinoSolutions/dodomain-python is a public repo on GitHub by DevinoSolutions. Official Python SDK for doDomain — connect your customers' custom domains. It declares the MIT license on GitHub. It is written mainly in Python, has 0 stars and last changed on 2026-11-20. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-22.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
Official Python SDK for doDomain — connect your customers' custom domains without becoming a DNS support desk.
You mint a connect session, send the customer to a hosted flow that detects their DNS provider and walks them through (or one-clicks) the records, and you get a signed webhook when the domain goes live.
This SDK covers all 18 callable REST operations, sync and async, plus webhook
signature verification. (The API's other four routes are browser navigations that
answer 302 on every path; the SDK exposes them as URL builders and never fetches
them.)
pip install dodomain-sdk
Requires Python 3.10+. The only runtime dependency is httpx.
The distribution is published as
dodomain-sdk, but the import package isdodomain—pip install dodomain-sdk, thenfrom dodomain import DoDomain.
Every authenticated call takes your app's secret key — a dd_sk_… value from
the doDomain dashboard (your app → API keys). Keep it server-side and read it from
the environment:
export DODOMAIN_SECRET_KEY="dd_sk_live_…"
import os from dodomain import DoDomain client = DoDomain(secret_key=os.environ["DODOMAIN_SECRET_KEY"])
A secret key is app-scoped — the app is implicit in the key. If you are
integrating through OAuth instead (the MCP/agent path), pass the access token as
secret_key; the SDK detects it, and app_id then becomes required on
sessions.create because an OAuth token is team-scoped.
import os from dodomain import DoDomain, DnsRecord client = DoDomain(secret_key=os.environ["DODOMAIN_SECRET_KEY"]) session = client.sessions.create( domain="app.customer.com", records=[DnsRecord(type="CNAME", host="app", value="cname.dodomain.io")], return_url="https://customer.com/settings/domains", ) print(session.connect_url) # send your customer here print(session.expires_at) # 24 hours from now, timezone-aware for record in session.records: print(record.fqdn) # the name we will actually verify — check this
Render session.connect_url as a link or redirect. When the customer finishes,
doDomain fires a connection.verified webhook carrying session.id as
sessionId, so you can correlate it back to the row you just wrote.
Read session.records before you show the customer anything. The API composes
each host under your domain, so domain="links.acme.com" with host="links"
is verified at links.links.acme.com — a doubled label that used to surface only
as a mysteriously failing verify. session.warnings carries advisories about a
request that was accepted anyway (duplicate_host_label is the one that exists
today); a warning never changes the status code.
The type
sessions.createreturns isConnectSessionSummary. It was calledSessionthrough 0.3.0, andfrom dodomain import Sessionstill works — the alias is the same class object, is deprecated, and goes away in the next major.@dodomain/node0.5.0 made the identical rename, for the identical reason: "session" already meant two other things in the platform.
Keyless mode is new in dodomain-sdk 0.7.0 (the twin of @dodomain/node 0.9.x):
with an older version, use the plain-HTTP script in
Keyless start instead.
No account and no key yet? A keyless client gets 10 test connections for its keyless app. Claiming the app with a free account gives it its own secret key and moves it into your Free allowance of 50 verified connections a month, shared with your other Free teams; paid plans raise that again (pricing).
import os from dodomain import DoDomain, DnsRecord # Reuse the same keyless app across runs: its dd_ks_ key lives in your secret store or env. client = DoDomain(keyless=True, keyless_key=os.environ.get("DODOMAIN_KEYLESS_KEY")) session = client.sessions.create( # Change this to a domain whose DNS you control: a keyless call refuses a placeholder or # reserved domain (customer.com, YOUR-DOMAIN.example) with 400 KEYLESS_PLACEHOLDER_DOMAIN. domain="YOUR-DOMAIN.example", records=[DnsRecord(type="CNAME", host="app", value="edge.yourproduct.com")], ) # session.connect_url: open it, add the records, watch it verify. # session.keyless.allowance: limit, used, open, remaining. if "DODOMAIN_KEYLESS_KEY" not in os.environ and client.keyless_key is not None: # Returned once. Store it like a password (your secret manager, platform env vars or a # gitignored .env); never log it, commit it or paste it anywhere public. save_secret("DODOMAIN_KEYLESS_KEY", client.keyless_key) # your own secret store
Pass app_name="..." on the first sessions.create to name the test app:
doDomain's hosted connect page shows it next to a "Test app" chip, and it is never
sent to a DNS provider until the app is claimed (until then the app is "DoDomain
test app" everywhere else).
session.keyless.claim_url carries the key after its #. Hand it only to the
person who will claim the app (your own UI or a direct message), never in a log, a
commit, an issue or a public channel. Neither it nor the key appears in the
model's repr(), and every error redacts any dd_ks_ key to dd_ks_… (its
message, details and body alike), so logging a caught error does not leak it.
The first sessions.create calls POST /api/v1/keyless/sessions with no key,
gets the API's 428 proof-of-work challenge, solves it with hashlib (about 1 to
3 seconds at the usual 20 bits; the API never asks for more than 24) and retries
with the proof. If that retry is refused because the network now needs a harder
proof or the challenge expired while solving, it solves the fresh challenge once
more, never more. The client then keeps the returned dd_ks_ key
(client.keyless_key), so later calls need no proof. To keep using the same
keyless app from another process, pass the key back:
DoDomain(keyless=True, keyless_key=...). Concurrent creates on a fresh client
start ONE keyless app and share its key. AsyncDoDomain(keyless=True) works the
same way and yields to the event loop while it solves.
Keyless mode is an explicit opt-in: DoDomain(secret_key=None) still raises, so
an unset environment variable never turns a production client into a test app. A
keyless client can create sessions, read client.keyless.status() (the
allowance and claim link) and call the token-public session routes
(retrieve, detect, verify); every other call raises DoDomainKeylessError
with code == "KEYLESS_MODE" (and status_code == 0, no request sent) until you
claim the app and switch to its dd_sk_ key. Keyless refusals from the API
(KEYLESS_LIMIT_REACHED, KEYLESS_START_RATE_LIMITED,
KEYLESS_CAPACITY_REACHED, KEYLESS_PLACEHOLDER_DOMAIN, …) raise
DoDomainKeylessError too, with the refusal's details (the limit and the link
that unlocks more) and, on the fair-share refusals, retry_at / retry_after.
proof_timeout= (seconds, above 0 and at most 300, default 120) bounds one
solve, and abort= (a threading.Event, or an asyncio.Event on the async
client) stops it with KEYLESS_PROOF_ABORTED. Full rules:
dodomain.io/docs/getting-started#keyless-start.
solve_keyless_proof(challenge, difficulty_bits, *, timeout=120.0, abort=None)
(and async_solve_keyless_proof) is the solver itself, exported for callers that
drive the REST API directly. It returns the full <challenge>:<nonce> value for
the DoDomain-Keyless-Proof header and raises DoDomainKeylessError
(KEYLESS_PROOF_UNSUPPORTED above 24 bits, KEYLESS_PROOF_ABORTED,
KEYLESS_PROOF_TIMEOUT).
Two different reads, and the difference matters. From your server, use
sessions.get(session_id) — it takes your credential, it is addressable by the
sessionId every webhook carries, and it still answers after the session expired:
state = client.sessions.get("cs_01HZX") state.status # "verified" state.expired # True once the 24h TTL passed — even before the reaper catches up state.connection_id # the DomainConnection id, or None if it never finalized state.records # composed names (type/host/fqdn) — no `value` on this arm state.tls_issuance_advisories # what the last verify pass found about certificates
The token-public routes are the other read: they take the session token in the path as the capability, send no credential at all, and are what a browser or a customer-side process can call:
public = client.sessions.retrieve(session.token) # status, records, detected tier detected = client.sessions.detect(session.token) # provider, tier, manual guide result = client.sessions.verify(session.token) # check live DNS now for record in result.records: print(record.fqdn, record.type, record.outcome) print(record.authoritative_found) # what their OWN nameservers answered print(record.public_found) # what a public resolver sees — trails, when propagating
retrieve raises ExpiredError forever once the TTL passes — correct for a
capability URL, useless for support, which is exactly why get exists.
Two endpoints are browser navigations, not API calls — they answer 302 on
every path. The SDK exposes them as URL builders so you can render your own CTA,
and never fetches them:
session.cloudflare_start_url # tier-1 Cloudflare OAuth flow session.domain_connect_start_url # tier-2 Domain Connect one-click
A verified record means DNS points at you. It does not mean a CA will hand you a certificate for that name. Every verify pass reads the domain's own nameservers for the two things that usually stop issuance and reports them as advisories:
result = client.sessions.verify(session.token) for advisory in result.advisories: print(advisory.severity, advisory.code, advisory.fqdn) print(advisory.note) # one human-readable sentence print(advisory.evidence_fqdn, advisory.evidence) # where we read it, and what it said
code |
What it means |
|---|---|
caa_excludes_issuer |
A CAA policy leaves out the CA your app is configured with |
caa_restricts_issuance |
A CAA policy exists and no CA is configured to judge it against |
stale_acme_challenge |
_acme-challenge.<fqdn> already holds a TXT or CNAME |
tls_issuance_unchecked |
The check itself could not complete — unknown, which is not clean |
An advisory never changes the verdict. verified and present are computed
without it, so a consumer that ignores the field sees exactly the contract that
shipped before advisories existed. severity is "warning" when it plausibly
breaks issuance for you and "info" when it is a fact we could not turn into a
verdict. An empty list means we looked and found nothing; a check that could not
run is an entry, not silence.
The same shape rides on sessions.get(...).tls_issuance_advisories (a snapshot
from the last verify pass, empty until one has run) and, when non-empty, on the
connection.verified and session.completed webhook payloads as
tlsIssuanceAdvisories. Configure which CA you issue with in the dashboard — it
is what turns the vague caa_restricts_issuance into the actionable
caa_excludes_issuer, and it reads back as app.tls_issuer_ca.
AsyncDoDomain has the identical resource tree, arguments and return types —
every method is awaitable and list_all is an async iterator.
import asyncio import os from dodomain import AsyncDoDomain, DnsRecord async def main() -> None: async with AsyncDoDomain(secret_key=os.environ["DODOMAIN_SECRET_KEY"]) as client: session = await client.sessions.create( domain="app.customer.com", records=[DnsRecord(type="CNAME", host="app", value="cname.dodomain.io")], ) print(session.connect_url) async for connection in client.connections.list_all(): print(connection.id, connection.status) asyncio.run(main())
A connection is a customer domain that went live. doDomain keeps checking its DNS and tells you when it drifts.
# Hold an id from a webhook? Read that one connection directly. conn = client.connections.get("conn_123") conn.status # "active" | "broken" conn.record_fqdns # ("status.customer.com",) — the names we actually monitor conn.disconnected_at # not None => monitoring stopped page = client.connections.list(limit=100) page.connections # tuple[Connection, ...] page.next_cursor # str | None — opaque, pass it straight back page.has_more # bool # Auto-paginating iterator — the ergonomic default. for connection in client.connections.list_all(domain="app.customer.com"): print(connection.id, connection.status, connection.verified_at) # Include the ones you disconnected, to reconcile against the archive. for connection in client.connections.list_all(include_disconnected=True): print(connection.id, connection.disconnected_at)
The cursor is opaque by contract. Pass next_cursor back unchanged; never
construct, parse or persist its internals.
# Ask for an on-demand DNS re-check. Answers 202 — the outcome arrives as a # connection.verified / connection.failed webhook, not in this response. client.connections.reverify("conn_123") # Stop monitoring a domain the customer removed from your product. result = client.connections.disconnect("conn_123") result.disconnected_at # datetime result.already_disconnected # False on the call that did it, True on a repeat
disconnect is idempotent by construction: a repeat returns the original
disconnected_at and emits no second webhook.
A connection owned by another app or team answers 404, never 403 — the API
refuses to confirm that someone else's id exists, and this SDK does not
reinterpret that as a permission problem. get is the exception to the list's
default in one way: it does return a disconnected connection, because a caller
naming an id already knows the row exists.
Read
record_fqdns, notfqdn.Connection.fqdnhas always been written as the session's domain, so a connection verified forstatus.acme.comreportsfqdn="acme.com". It cannot be fixed in place — a session may carry several records, so there is no single honest "the" fqdn — and it keeps its value for the integrators already reading it.record_fqdnscarries the real answer: every name doDomain monitors for that connection.
Manage delivery targets from CI or IaC instead of the dashboard. Secret-key
only — an OAuth token is refused with a 403 whose
exc.secret_key_required is True.
endpoint = client.webhook_endpoints.create(url="https://acme.example/webhooks/dodomain") endpoint.secret # "whsec_…" — SHOWN ONCE. Store it now. for e in client.webhook_endpoints.list(): print(e.id, e.url, e.paused_at) # never carries a secret; paused_at is None unless auto-paused client.webhook_endpoints.update("whe_123", url="https://acme.example/v2") # secret unchanged rotated = client.webhook_endpoints.rotate_secret("whe_123") rotated.secret # the new one, also shown once client.webhook_endpoints.resume("whe_123") # clears paused_at; a no-op if it is not paused client.webhook_endpoints.delete("whe_123")
Three things that will bite if assumed away:
create and rotate_secret return it and
nothing else ever does. It is kept out of the object's repr so a traceback
cannot spill it into your logs; read it off .secret.get(endpoint_id) is a client-side lookup over list() — the API has no
read-one route — so it costs one list request, and the NotFoundError it raises
carries status_code == 0 because no 404 came back from the server.doDomain pauses an endpoint by itself once it has had no successful delivery
for 7 days and at least 5 dead-lettered deliveries in that span; paused_at
holds when that happened. While paused, new events are still recorded as
deliveries but marked skipped and never sent.
resume(endpoint_id) clears paused_at and restarts the 7-day clock. It is
idempotent — an endpoint that is not paused comes back unchanged, so a
reconciler may call it unconditionally. It does not resend the skipped
deliveries; redrive those from the dashboard. An update that actually changes
the url resumes the endpoint too.
rotated = client.keys.rotate() rotated.secret_key # the NEW dd_sk_… — the only copy that will ever exist rotated.public_key # unchanged, so CI can assert it rewrote the right app rotated.previous_key_expires_at # None: the old key is already dead
The default is an immediate cutover. The key you authenticated the call with
stops working the instant the response is produced. Write rotated.secret_key to
your secret store before doing anything else — drop it and you are locked out
until you rotate again from the dashboard. The client you called it on still
holds the old key; build a new one from the result.
If you cannot deploy the new key in the same breath, ask for an overlap window and both keys authenticate until it closes:
rotated = client.keys.rotate(overlap_hours=24) # 0 (default), 1 or 24 rotated.previous_key_expires_at # when the OLD key stops working
Rotate, ship rotated.secret_key everywhere, and let the old one lapse on its
own. Three things to hold on to:
keys.rotate() with the
default also terminates a window still running from an earlier rotation, which
is how you revoke a previous key early.401.There is deliberately no keys.create, keys.list or keys.revoke: key
inventory stays behind a human dashboard session, so a stolen key can never mint a
second hidden credential that survives you rotating the one you know about.
Rotating is the revoke.
Find out how a domain would connect before you create anything. Stateless, persists nothing, available on every plan:
check = client.domains.check(domain="app.customer.com") check.zone # "customer.com" — the registrable apex DNS is managed at check.provider # "cloudflare" check.tier # 1 | 2 | 3 check.method # "oauth" | "domain-connect" | "guided" check.confidence # "high" | "medium" | "low" check.one_click_available # False on tier 2 when the provider serves none of our templates (e.g. GoDaddy) check.guide.steps # copy-ready manual instructions
for app in client.apps.list(): print(app.id, app.name, app.public_key, app.sandbox) print(app.tls_issuer_ca) # the CA your certificates are issued with, or None print(app.connect_headline, app.connect_font_preset) # white-label settings, or None
A secret key sees exactly its own app — listing siblings would widen a single leaked key into team-wide reconnaissance. The model carries no secret material.
doDomain signs every delivery Stripe-style:
x-dodomain-signature: t=<unix millis>,v1=<hex sha256 hmac>
x-dodomain-event: connection.verified
x-dodomain-delivery-id: whd_…
Verify against the raw request body, before any JSON parsing — re-serializing a parsed body changes the bytes and the signature will not match.
import json import os from dodomain import verify_webhook @app.post("/webhooks/dodomain") async def handle(request): raw = await request.body() signature = request.headers.get("x-dodomain-signature", "") if not verify_webhook(os.environ["DODOMAIN_WEBHOOK_SECRET"], raw, signature): return Response(status_code=400) event = json.loads(raw) ...
verify_webhook(secret, body, header, tolerance_ms=300_000, now_ms=None) -> bool
body may be str or bytes; secret too.v1, and outright garbage are all just False — an
attacker cannot turn a crafted header into a 500 inside your handler.{
"id": "whd_…",
"type": "connection.verified",
"occurredAt": "2026-08-17T10:00:00.000Z",
"data": { "sessionId": "cs_…", "connectionId": "conn_…" },
"event": "connection.verified"
}Read type. Dedupe on id — it is stable across retries and is the same
value as the x-dodomain-delivery-id header, so you can dedupe before parsing the
body at all. event is a deprecated alias of type, byte-identical to it,
kept only so receivers written before the 2026-08-06 envelope cutover keep
parsing; do not write new code against it.
data always carries sessionId as your correlation handle, and every payload
that announces a connection also carries connectionId — the id
connections.get / reverify / disconnect are keyed by. connection.verified
and session.completed additionally carry tlsIssuanceAdvisories when there is
at least one, in the shape described under
Will the certificate issue? — absent, not empty,
when there is nothing to say.
Event types: connection.verified, connection.failed,
connection.disconnected, session.completed, session.abandoned. A receiver
that does not recognise a type must ignore it — the vocabulary grows additively.
No typed event parser ships, on purpose. Both the event vocabulary and the payload fields grow additively, so a strict parser would reject a delivery the day the API adds a type — exactly the failure a webhook receiver must not have.
verify_webhookchecks the HMAC and nothing else, which is what makes it safe across every additive change.
Every failure is a subclass of DoDomainError. Nothing raw — not a
JSONDecodeError from a proxy's HTML 502, not an httpx timeout — escapes.
from dodomain import DoDomainAPIError, NotFoundError, RateLimitError try: client.connections.reverify("conn_123") except NotFoundError: ... # unknown id, or one you do not own except RateLimitError as exc: print(exc.reason, exc.retry_after) except DoDomainAPIError as exc: print(exc.message, exc.error, exc.code, exc.status_code, exc.details)
An API refusal's exc.message is its machine error followed by the API's own
explanation (since 0.7.0, the twin of @dodomain/node 0.9.2), and exc.error /
exc.code carry the machine values, so branch on those (or on the exception
class), not on the message:
from dodomain import DoDomainKeylessError try: client.sessions.create(domain="customer.com", records=records) except DoDomainKeylessError as exc: # exc.message: 'invalid_request: "customer.com" is a placeholder or reserved name, ...' # exc.code: "KEYLESS_PLACEHOLDER_DOMAIN"; on a fair-share 402/429, exc.retry_at says when. print(exc.message, exc.code, exc.retry_at) except DoDomainAPIError as exc: print(exc.message, exc.error, exc.code, exc.status_code)
exc.error is the machine error ("invalid_request", "quota_exceeded"), or
None on an error the SDK raised itself (status_code == 0).exc.code is the machine error too, unless the API sent a stable denial code
on a problem+json answer, which then wins. On DoDomainKeylessError it is
always the KEYLESS_* code.exc.detail is the API's human text alone, or None.API error code |
Exception | Status |
|---|---|---|
unauthorized |
AuthenticationError |
401 |
forbidden |
PermissionError_ |
403 |
not_found |
NotFoundError |
404 |
expired |
ExpiredError |
410 |
invalid_request |
InvalidRequestError |
400 |
quota_exceeded |
QuotaExceededError |
402 |
not_configured |
NotConfiguredError |
503 |
conflict |
ConflictError |
409 |
rate_limited |
RateLimitError |
429 |
internal |
InternalServerError |
500 |
(any KEYLESS_* denial code) |
DoDomainKeylessError |
as sent |
| (anything else) | DoDomainAPIError |
as sent |
Plus, outside the HTTP layer: DoDomainConfigError (bad constructor options),
DoDomainConnectionError (no response was ever received), and
InvalidResponseError (a 2xx body that does not match the contract).
The API's human text is frequently absent. It drops the message field on most
thrown errors; exc.message then falls back to the machine error alone (or
HTTP <status> when the body named none), and exc.detail is None. str(exc)
adds the request for you:
doDomain API error: POST /api/v1/sessions returned HTTP 402 (quota_exceeded)
An InvalidRequestError raised by the SDK's own input validation carries
status_code == 0: no request was sent.
The plan cap starts at 60 requests/minute, in fixed 60-second windows. A 429
carries Retry-After, and — importantly — two different meanings:
except RateLimitError as exc: if exc.reason == "recently_checked": # This ONE connection was DNS-checked inside its 10-minute cooldown. # Nothing global is throttled. Do NOT retry — show "checked recently, # try again in a few minutes". A backoff loop here only burns your plan # quota against the other limiter. show_cooldown_notice(exc.retry_after) else: # reason == "request_rate" # You are calling too fast. exc.limit is the per-minute cap. back_off(exc.retry_after)
The SDK already does the right thing for you: it retries request_rate
(honouring Retry-After) and raises recently_checked immediately.
client.last_rate_limit holds a snapshot of the most recent response's rate-limit
headers. The API emits only Retry-After today, so the IETF draft-11
RateLimit-* fields are None; they are read opportunistically so the SDK
already reports them the day the API adopts them.
client = DoDomain( secret_key="dd_sk_…", base_url="https://app.dodomain.io", # the only origin that serves /api/v1 timeout=30.0, max_retries=2, http_client=None, # bring your own httpx.Client ) # Or, with no account and no key (see "Try it with no account" above): client = DoDomain( keyless=True, keyless_key=None, # a dd_ks_ key from an earlier keyless start, to reuse that app proof_timeout=120.0, # seconds one proof-of-work solve may take, at most 300 )
GET and DELETE only, on 429/5xx/transport errors,
with exponential backoff and full jitter (base 0.5s, cap 8s). A Retry-After
above 60 seconds is raised rather than slept through.POST is never retried. The API has no server-side idempotency, so a
replayed POST /v1/sessions would mint a second session and burn a second unit
of plan quota. sessions.verify and connections.disconnect are idempotent
server-side, so retrying those yourself is safe.idempotency_key is accepted on every write method and forwarded as
Idempotency-Key. The API does not currently honour it; the plumbing is there
so the eventual server-side landing is a non-event.
client.new_idempotency_key() mints one.with / async with) and expose .close().
An injected http_client is never closed by the SDK.python -m venv .venv && source .venv/bin/activate pip install -e ".[dev]" ruff check . && ruff format --check . && ty check pytest tests --ignore=tests/e2e --cov=dodomain --cov-fail-under=90
The unit suite mocks the wire with respx and asserts on the actual request —
URL, method, headers, JSON body — as well as the parsed return value, so it tests
the protocol rather than the mock.
tests/fixtures/webhook_vectors.json is generated by the TypeScript
signWebhook in the doDomain monorepo (packages/core/src/webhook.ts), executed
directly with node --experimental-strip-types. It is the guard against the
Python and TypeScript verifiers drifting apart.
tests/e2e/ runs against production and skips loudly without
DODOMAIN_SECRET_KEY:
DODOMAIN_SECRET_KEY="dd_sk_…" pytest tests/e2e -vThis SDK is hand-written, not generated. doDomain does publish an OpenAPI 3.1 document — https://dodomain.io/docs/openapi.json, generated from the same zod schemas the route handlers validate with — and it is the right thing to check this SDK's shapes against, but the hand-written surface is deliberate: the naming, the sync/async twins, the local validation and the docstrings that explain why an endpoint behaves the way it does are the product here, and none of them survive a generator.
MIT © 2026 Devino Solutions Inc.
DevinoSolutions/dodomain-python is a public repo on GitHub by DevinoSolutions. Official Python SDK for doDomain — connect your customers' custom domains.
It declares the MIT license on GitHub.
Its maker tagged it for Windows. That is declared by the maker; Take My Repo has not tested it.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2026-11-20. GitHub counts 2 open issues and pull requests. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Open-Source API Development Ecosystem • https://hoppscotch.io • Offline, On-Prem & Cloud • Web, Desktop & CLI • Open-Source Alternative to Postman, Insomnia
100% open-source, AI-native web analytics with cookieless tracking, open exports, custom domains, and SSO—self-hosted as one Go binary or managed in EU/US cloud.
Official DoDomain SDKs — @dodomain/node (server) + @dodomain/connect (browser widget). Read-only mirror; issues welcome.
A Python library for building AI agents that leverage the full power of Google Antigravity.

Opensource IDE For Exploring and Testing API's (lightweight alternative to Postman/Insomnia)

Learn how to deploy serverless containerized apps on Kubernetes with Knative.

The open-source and privacy-first alternative to Honey. Caramel The Trusted Alternative To Honey For Finding Coupons

Desktop & phone notifications for AI coding agents (Claude Code, Codex, Gemini CLI, Cursor). Native VS Code support. Toast + ntfy push. Zero dependencies.

Undetectable browser automation for AI agents via MCP. Stealth Chrome DevTools with smart profile management, anti-detection arg filtering, and CDP access.

Open-source TypeScript file uploader for React, Vue, Svelte, Angular, Preact, Next.js and vanilla JS. Drag-and-drop, presigned-URL uploads to AWS S3, DigitalOcean Spaces, Backblaze B2, Azure, MinIO and other S3 providers, from device, Google Drive, OneDrive, Dropbox or Box.
Launch each project's AI coding agent (Claude Code, Codex, Cursor) in its own terminal and auto-tile every window across all your monitors - DPI-correct on mixed-scale setups.
Public, secret-free CI lint tooling and reusable workflow for DevinoSolutions repos
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/DevinoSolutions/dodomain-pythonTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.