Integrate Jobyhood jobs

<script src="https://jobyhood.com/embed/v1.js"
        data-key="pk_your_public_key" data-lang="bg" data-theme="auto"
        data-accent="#0C68E9" data-filters="city=Sofia" async></script>
<script>
  window.addEventListener('load', () => {
    // {kind}; matches_available also carries {count} (a number only).
    JobyhoodJobs.onEvent = (event) => {
      if (event.kind === 'matches_available') showBadge(event.count);
    };
    // "Continue with …" and no token yet: mint one on your server, then hand it over.
    JobyhoodJobs.onNeedsToken = async () => {
      const response = await fetch('/jobyhood-token', { credentials: 'include' });
      const { token } = await response.json();
      JobyhoodJobs.setToken(token);
    };
  });
</script>

// <iframe id="jobyhood" src="https://jobyhood.com/embed/jobs?key=pk_your_public_key&lang=bg"
//         title="Jobs" style="width:100%;border:0"></iframe>
const JOBYHOOD = 'https://jobyhood.com';
const frame = document.getElementById('jobyhood');

window.addEventListener('message', async (event) => {
  if (event.origin !== JOBYHOOD || event.source !== frame.contentWindow) return;
  const message = event.data || {};
  if (message.type === 'jobyhood:resize') {
    frame.style.height = `${Math.max(240, Math.ceil(message.height))}px`;
  } else if (message.type === 'jobyhood:event') {
    track(message.kind, message.count);
  } else if (message.type === 'jobyhood:needs-token') {
    const { token } = await fetch('/jobyhood-token', { credentials: 'include' }).then((r) => r.json());
    frame.contentWindow.postMessage({ type: 'jobyhood:token', token }, JOBYHOOD);
  }
});

// Later, to change what the list shows:
frame.contentWindow.postMessage({ type: 'jobyhood:filters', filters: { city: 'Varna' } }, JOBYHOOD);

import crypto from 'node:crypto';
import jwt from 'jsonwebtoken';

// GET /jobyhood-token, for your signed-in user only. The secret never leaves your server.
app.get('/jobyhood-token', requireLogin, (req, res) => {
  const token = jwt.sign(
    {
      sub: String(req.user.id),
      email: req.user.email,
      email_verified: true,
      given_name: req.user.firstName,
      locale: 'bg',
      jti: crypto.randomUUID(),
    },
    process.env.JOBYHOOD_SERVER_SECRET,
    { algorithm: 'HS256', issuer: 'your-partner-slug', audience: 'jobyhood', expiresIn: '5m' }
  );
  res.set('Cache-Control', 'no-store').json({ token });
});

import os
import time
import uuid

import jwt  # PyJWT


def jobyhood_token(user) -> str:
    """A single-use sign-in token for a user you have already authenticated."""
    now = int(time.time())
    claims = {
        "iss": "your-partner-slug",
        "aud": "jobyhood",
        "sub": str(user.id),
        "email": user.email,
        "email_verified": True,
        "given_name": user.first_name,
        "locale": "bg",
        "iat": now,
        "exp": now + 300,
        "jti": str(uuid.uuid4()),
    }
    return jwt.encode(claims, os.environ["JOBYHOOD_SERVER_SECRET"], algorithm="HS256")

POST https://api.jobyhood.com/v1/partners/sso/
X-Jobyhood-Partner-Key: pk_your_public_key
Content-Type: application/json

{"token": "<jwt>", "consent_version": "<consentVersion from config>"}

200 {"access": "…", "refresh": "…", "created": true, "needsOnboarding": true,
     "user": {"id": 1, "email": "…", "firstName": "…"}}
400 {"code": "consent_required"}

POST https://api.jobyhood.com/v1/partners/link/
X-Jobyhood-Partner-Key: pk_your_public_key
Authorization: Bearer <the user’s Jobyhood access token>
Content-Type: application/json

{"token": "<the same jwt>", "consent_version": "<consentVersion from config>"}

https://jobyhood.com/embed/jobs?key=pk_your_public_key&lang=bg

class JobsActivity : AppCompatActivity() {
    private lateinit var web: WebView

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        web = WebView(this).also(::setContentView)
        web.settings.javaScriptEnabled = true
        web.settings.domStorageEnabled = true // the embed keeps its session here
        web.settings.setSupportMultipleWindows(true) // the "connect your account" pop-up
        web.addJavascriptInterface(Bridge(), "JobyhoodApp") // events; e-mail-only sign-in in the pop-up
        web.webChromeClient = Popups()
        web.loadUrl("https://jobyhood.com/embed/jobs?key=pk_your_public_key&lang=bg")
    }

    inner class Bridge {
        @JavascriptInterface
        fun postMessage(json: String) {
            val message = JSONObject(json)
            when (message.getString("type")) {
                "jobyhood:needs-token" -> lifecycleScope.launch {
                    val token = yourBackend.jobyhoodToken() // see "Sign-in token"
                    web.evaluateJavascript("JobyhoodJobs.setToken(${JSONObject.quote(token)})", null)
                }
                "jobyhood:event" -> if (message.getString("kind") == "matches_available") {
                    runOnUiThread { showBadge(message.getInt("count")) }
                }
            }
        }
    }

    // The pop-up opens in a web view of its own, so it can hand the session back to the embed.
    inner class Popups : WebChromeClient() {
        override fun onCreateWindow(view: WebView, dialog: Boolean, gesture: Boolean, msg: Message): Boolean {
            val popup = WebView(this@JobsActivity).apply {
                settings.javaScriptEnabled = true
                settings.domStorageEnabled = true
                webViewClient = WebViewClient()
                webChromeClient = this@Popups
            }
            popup.tag = Dialog(this@JobsActivity).apply { setContentView(popup); show() }
            (msg.obj as WebView.WebViewTransport).webView = popup
            msg.sendToTarget()
            return true
        }

        override fun onCloseWindow(window: WebView) {
            (window.tag as? Dialog)?.dismiss()
            window.destroy()
        }
    }
}

import UIKit
import WebKit

final class JobsViewController: UIViewController, WKScriptMessageHandler, WKUIDelegate {
    private var webView: WKWebView!

    override func viewDidLoad() {
        super.viewDidLoad()
        let config = WKWebViewConfiguration()
        config.userContentController.add(self, name: "jobyhood") // events; e-mail-only sign-in in the pop-up
        webView = WKWebView(frame: view.bounds, configuration: config)
        webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        webView.uiDelegate = self
        view.addSubview(webView)
        var url = URLComponents(string: "https://jobyhood.com/embed/jobs")!
        url.queryItems = [URLQueryItem(name: "key", value: "pk_your_public_key"),
                          URLQueryItem(name: "lang", value: "bg")]
        webView.load(URLRequest(url: url.url!))
    }

    func userContentController(_ controller: WKUserContentController, didReceive message: WKScriptMessage) {
        guard let text = message.body as? String,
              let json = try? JSONSerialization.jsonObject(with: Data(text.utf8)) as? [String: Any],
              let type = json["type"] as? String else { return }
        if type == "jobyhood:needs-token" {
            Task {
                let token = try await yourBackend.jobyhoodToken() // see "Sign-in token"
                let literal = String(data: try JSONEncoder().encode(token), encoding: .utf8)!
                _ = try? await webView.evaluateJavaScript("JobyhoodJobs.setToken(\(literal))")
            }
        } else if type == "jobyhood:event", json["kind"] as? String == "matches_available",
                  let count = json["count"] as? Int {
            showBadge(count)
        }
    }

    // The pop-up opens in a web view of its own, so it can hand the session back to the embed.
    func webView(_ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration,
                 for action: WKNavigationAction, windowFeatures: WKWindowFeatures) -> WKWebView? {
        let popup = WKWebView(frame: view.bounds, configuration: configuration)
        popup.uiDelegate = self
        view.addSubview(popup)
        return popup
    }

    func webViewDidClose(_ webView: WKWebView) { webView.removeFromSuperview() }
}

curl -H "X-Jobyhood-Partner-Key: pk_your_public_key" \
  "https://api.jobyhood.com/v1/jobs/?city=Sofia&page_size=20"

curl -X POST https://api.jobyhood.com/v1/partners/events/ \
  -H "X-Jobyhood-Partner-Key: pk_your_public_key" -H "Content-Type: application/json" \
  -d '{"kind": "job_view", "job_posting_id": 42}'

curl -X POST https://matcher.jobyhood.com/v1/matcher/onboarding-chat/ \
  -H "X-Jobyhood-Partner-Key: pk_your_public_key" \
  -H "Authorization: Bearer <the user’s access token>" -H "Content-Type: application/json" \
  -d '{"message": "Hi", "conversation_history": [], "extracted_data": {}, "language": "bg"}'

GET https://api.jobyhood.com/v1/partners/stats/?from=2026-10-01&to=2026-10-21
Authorization: Partner <server secret>

200 {"range": {…}, "totals": {"impressions": 1200, "jobViews": 340, "signups": 25, "logins": 60, "interests": 18},
     "daily": [{"date": "2026-10-01", "impressions": 40, "jobViews": 11, "signups": 1, "logins": 2, "interests": 0}, …]}