Custom Webhook Integration

const express = require("express");
const app = express();

const ACCESS_KEY = process.env.SKRIBRA_ACCESS_KEY;

function verifyWebhook(req, res, next) {
  const authHeader = req.headers.authorization;
  if (!authHeader || !authHeader.startsWith("Bearer ")) {
    return res.status(401).json({ error: "Missing authorization" });
  }
  const token = authHeader.split(" ")[1];
  if (token !== ACCESS_KEY) {
    return res.status(401).json({ error: "Invalid access key" });
  }
  next();
}

app.use(express.json());
app.post("/api/webhooks/skribra", verifyWebhook, (req, res) => {
  // Process the webhook payload
  res.status(200).json({ success: true });
});

from flask import Flask, request, jsonify
import os

app = Flask(__name__)
ACCESS_KEY = os.environ.get("SKRIBRA_ACCESS_KEY")

@app.route("/api/webhooks/skribra", methods=["POST"])
def handle_webhook():
    auth_header = request.headers.get("Authorization", "")
    if not auth_header.startswith("Bearer "):
        return jsonify({"error": "Missing authorization"}), 401

    token = auth_header.split(" ")[1]
    if token != ACCESS_KEY:
        return jsonify({"error": "Invalid access key"}), 401

    payload = request.get_json()
    for article in payload["data"]["articles"]:
        print(f"Received: {article['title']}")
        # Save to database

    return jsonify({"success": True})

<?php
$accessKey = getenv("SKRIBRA_ACCESS_KEY");
$authHeader = $_SERVER["HTTP_AUTHORIZATION"] ?? "";

if (!str_starts_with($authHeader, "Bearer ")) {
    http_response_code(401);
    echo json_encode(["error" => "Missing authorization"]);
    exit;
}

$token = substr($authHeader, 7);
if ($token !== $accessKey) {
    http_response_code(401);
    echo json_encode(["error" => "Invalid access key"]);
    exit;
}

$payload = json_decode(file_get_contents("php://input"), true);
foreach ($payload["data"]["articles"] as $article) {
    // Save to database
    error_log("Received: " . $article["title"]);
}

echo json_encode(["success" => true]);

package main

import (
    "encoding/json"
    "net/http"
    "os"
    "strings"
)

var accessKey = os.Getenv("SKRIBRA_ACCESS_KEY")

func webhookHandler(w http.ResponseWriter, r *http.Request) {
    authHeader := r.Header.Get("Authorization")
    if !strings.HasPrefix(authHeader, "Bearer ") {
        w.WriteHeader(http.StatusUnauthorized)
        json.NewEncoder(w).Encode(map[string]string{"error": "Missing authorization"})
        return
    }

    token := strings.TrimPrefix(authHeader, "Bearer ")
    if token != accessKey {
        w.WriteHeader(http.StatusUnauthorized)
        json.NewEncoder(w).Encode(map[string]string{"error": "Invalid access key"})
        return
    }

    // Process the webhook payload
    json.NewEncoder(w).Encode(map[string]bool{"success": true})
}

func main() {
    http.HandleFunc("/api/webhooks/skribra", webhookHandler)
    http.ListenAndServe(":8080", nil)
}

// React/Next.js component
interface ArticleProps {
  title: string;
  contentHtml: string;
  imageUrl?: string;
}

export function Article({ title, contentHtml, imageUrl }: ArticleProps) {
  return (
    <article className="prose">
      <h1>{title}</h1>
      {imageUrl && <img src={imageUrl} alt={title} />}
      <div dangerouslySetInnerHTML={{ __html: contentHtml }} />
    </article>
  );
}

{# Jinja2 template.html #}
<article class="prose">
  <h1>{{ article.title | e }}</h1>
  {% if article.image_url %}
    <img src="{{ article.image_url | e }}" alt="{{ article.title | e }}">
  {% endif %}
  <div class="content">
    {{ article.content_html | safe }}
  </div>
</article>

<?php
$article = $payload["data"]["articles"][0];
?>

<article class="prose">
  <h1><?= htmlspecialchars($article["title"]) ?></h1>
  <?php if (!empty($article["image_url"])): ?>
    <img src="<?= htmlspecialchars($article['image_url']) ?>" alt="<?= htmlspecialchars($article['title']) ?>">
  <?php endif; ?>
  <div class="content">
    <?= $article["content_html"] ?>
  </div>
</article>

package main

import (
    "html/template"
    "net/http"
)

type Article struct {
    Title       string
    ContentHTML template.HTML
    ImageURL    string
}

var tmpl = template.Must(template.New("article").Parse(`
<article class="prose">
  <h1>{{.Title}}</h1>
  {{if .ImageURL}}<img src="{{.ImageURL}}" alt="{{.Title}}">{{end}}
  <div class="content">{{.ContentHTML}}</div>
</article>
`))

func renderArticle(w http.ResponseWriter, article Article) {
    tmpl.Execute(w, article)
}

# Install markdown-it (recommended for server-side)
npm install markdown-it @types/markdown-it

# Or for client-side React components
npm install react-markdown remark-gfm

pip install markdown

composer require erusev/parsedown

go get github.com/gomarkdown/markdown

// lib/markdown.ts
import MarkdownIt from "markdown-it";

const md = new MarkdownIt({
  html: true,
  linkify: true,
  typographer: true,
});

export function renderMarkdown(markdown: string): string {
  if (!markdown) return "";
  return md.render(markdown);
}

// Usage in a page component
export default function ArticlePage({ article }) {
  return (
    <article className="prose">
      <h1>{article.title}</h1>
      <div
        dangerouslySetInnerHTML={{ 
          __html: renderMarkdown(article.content_markdown)
        }}
      />
    </article>
  );
}

import markdown

def render_article(article):
    html_content = markdown.markdown(
        article["content_markdown"],
        extensions=["tables", "fenced_code"]
    )
    return html_content

# In your Flask route or Django view
from flask import render_template

@app.route("/article/<slug>")
def show_article(slug):
    article = get_article_by_slug(slug)
    html_content = render_article(article)
    return render_template(
        "article.html",
        article=article,
        content=html_content
    )

<?php
require "vendor/autoload.php";

$parsedown = new Parsedown();
$article = $payload["data"]["articles"][0];
$htmlContent = $parsedown->text($article["content_markdown"]);
?>

<article class="prose">
  <h1><?= htmlspecialchars($article["title"]) ?></h1>
  <?= $htmlContent ?>
</article>

package main

import (
    "html/template"
    "github.com/gomarkdown/markdown"
    "github.com/gomarkdown/markdown/html"
    "github.com/gomarkdown/markdown/parser"
)

func renderMarkdown(md []byte) template.HTML {
    extensions := parser.CommonExtensions |
        parser.AutoHeadingIDs |
        parser.Tables
    p := parser.NewWithExtensions(extensions)

    opts := html.RendererOptions{Flags: html.CommonFlags}
    renderer := html.NewRenderer(opts)

    doc := p.Parse(md)
    return template.HTML(markdown.Render(doc, renderer))
}

// Usage in handler
func articleHandler(w http.ResponseWriter, r *http.Request) {
    article := getArticle(r.URL.Query().Get("slug"))
    htmlContent := renderMarkdown([]byte(article.ContentMarkdown))
    tmpl.Execute(w, map[string]any{
        "Title":   article.Title,
        "Content": htmlContent,
    })
}