ShareMyHTML APIsharemyhtml.com ↗
Access ShareMyHTML's global air kiss counter via 2 endpoints. Send 1–50 kisses per call and retrieve the cumulative total count in real time.
What is the ShareMyHTML API?
The ShareMyHTML API exposes 2 endpoints for interacting with the site's global air kiss feature. Use send_air_kisses to dispatch between 1 and 50 kisses in a single call and receive back both the number successfully sent and the updated global total, or call get_kiss_count to read the current cumulative kiss count without sending anything.
curl -X POST 'https://api.parse.bot/scraper/cbca0068-dc30-439c-8dd6-dda8029e7d92/send_air_kisses' \
-H 'X-API-Key: $PARSE_API_KEY' \
-H 'Content-Type: application/json' \
-d '{
"count": "10"
}'Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace sharemyhtml-com-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""Walkthrough: ShareMyHtml SDK — send air kisses and check the global count."""
from parse_apis.sharemyhtml_com_api import ShareMyHtml, ParseError
client = ShareMyHtml()
# Check the current global kiss count
status = client.kisses.count()
print(f"Current total air kisses: {status.total_count}")
# Send a batch of air kisses
result = client.kisses.send(count=10)
print(f"Sent {result.kisses_sent} kisses! New total: {result.total_count}")
# Error handling: wrap a call in a typed-error catch
try:
another = client.kisses.send(count=5)
print(f"Another batch: sent {another.kisses_sent}, total now {another.total_count}")
except ParseError as exc:
print(f"Request failed: {exc}")
print("exercised: kisses.count / kisses.send")
Send air kisses to ShareMyHTML. Each call sends the specified number of kisses (1-50) sequentially. Returns the number successfully sent and the new global total. Rate-limited to ~200 requests per minute server-side; if the limit is hit mid-batch, partial results are returned.
| Param | Type | Description |
|---|---|---|
| count | integer | Number of air kisses to send, between 1 and 50. |
{
"type": "object",
"fields": {
"kisses_sent": "integer",
"total_count": "integer"
},
"sample": {
"data": {
"kisses_sent": 50,
"total_count": 170936
},
"status": "success"
}
}About the ShareMyHTML API
Endpoints
The API covers two operations. GET get_kiss_count takes no parameters and returns a single field, total_count, representing the cumulative number of air kisses sent by all users since the counter began. POST send_air_kisses accepts an optional count integer (1–50) and returns two fields: kisses_sent, the number of kisses that were actually dispatched in this call, and total_count, the updated global figure after the batch completes.
Partial Results and Batch Behavior
When calling send_air_kisses, the count parameter controls how many kisses are sent sequentially in one request. If the server-side rate limit is reached mid-batch, the call returns partial results: kisses_sent may be less than the count you specified, while total_count reflects however many were recorded before the limit was hit. Checking kisses_sent against your requested count is the correct way to detect a partial batch.
Response Shape
Both endpoints share the total_count field, making it straightforward to keep a running tally without issuing a separate read after every write. All response values are integers; there are no nested objects, pagination tokens, or per-user breakdowns in the current response schema.
The ShareMyHTML API is a managed, monitored endpoint for sharemyhtml.com — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when sharemyhtml.com changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official sharemyhtml.com API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Poll
get_kiss_counton an interval to display a live global kiss counter on a dashboard or status page. - Use
send_air_kisseswithcount=50in a loop to automate appreciation campaigns for ShareMyHTML-hosted pages. - Compare
kisses_sentto the requestedcountto detect rate-limit collisions and implement automatic retry logic. - Record successive
total_countvalues over time to build a time-series chart of kiss velocity. - Trigger
send_air_kissesfrom a webhook when a page reaches a view milestone, linking engagement signals to kiss totals. - Read
total_countbefore and after asend_air_kissescall to verify the delta and audit kiss delivery accuracy.
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does ShareMyHTML provide an official developer API?+
What does `send_air_kisses` return if only some kisses are sent?+
kisses_sent (which will be lower than your requested count) and a total_count reflecting the partial delivery. You should always compare kisses_sent to your input count to confirm a full batch completed.Can I retrieve a per-user or per-page kiss breakdown rather than just the global total?+
total_count — there is no per-user or per-page segmentation in the current response fields. You can fork this API on Parse and revise it to add an endpoint targeting per-page or per-user kiss data if that granularity is available on the site.Is there a way to read historical kiss counts or a time-series from the API?+
get_kiss_count returns only the current global total with no timestamps or historical snapshots. You can fork this API on Parse and revise it to log successive total_count values with timestamps to build your own history.What is the valid range for the `count` parameter in `send_air_kisses`?+
count parameter accepts integers from 1 to 50. Values outside that range are not valid. If omitted, the endpoint applies its default behavior as documented.